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

version 1.12

version 1.13

Line 1

dnl aclocal.m4 generated automatically by aclocal 1.4-p6

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

dnl This file is free software; the Free Software Foundation

# Free Software Foundation, Inc.

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

# This file is free software; the Free Software Foundation

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

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

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

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

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

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

dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A

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

dnl PARTICULAR PURPOSE.

# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

# PARTICULAR PURPOSE.

AC_DEFUN([CF_CHECK_PYTHON],

Line 66

Line 67

AC_SUBST(PY_INCLUDES)

])

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

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

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"

])

dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,

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

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"

])

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

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

])

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

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

dnl unless already present in VAR.

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

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

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

])

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

# Free Software Foundation, Inc.

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

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

AC_DEFUN([AC_LIB_PROG_LD],

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

[AC_ARG_WITH(gnu-ld,

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

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

# any later version.

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

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

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

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

# But this isn't really a big deal.

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

# serial 1

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

dnl Usage:

# serial 8

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

AC_REQUIRE([AC_PROG_INSTALL])dnl

PACKAGE=[$1]

# test to see if srcdir already configured

AC_SUBST(PACKAGE)

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

VERSION=[$2]

test -f $srcdir/config.status; then

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

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

# Define the identity of the package.

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

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

AC_REQUIRE([AM_SANITY_CHECK])

m4_ifval([$2],

AC_REQUIRE([AC_ARG_PROGRAM])

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

dnl FIXME This is truly gross.

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

missing_dir=`cd $ac_aux_dir && pwd`

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

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

[_AM_SET_OPTIONS([$1])dnl

AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)

AC_SUBST([PACKAGE], [AC_PACKAGE_TARNAME])dnl

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

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

AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)

AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)

_AM_IF_OPTION([no-define],,

AC_REQUIRE([AC_PROG_MAKE_SET])])

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

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 939

Line 187

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

# 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.4"])

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

# 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.4-p6])])

[AM_AUTOMAKE_VERSION([1.6.3])])

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

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

AC_DEFUN([AM_SANITY_CHECK],

[AC_MSG_CHECKING([whether build environment is sane])

# Just in case

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

sleep 1

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

echo timestamp > conftestfile

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

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

# any later version.

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

# 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

# 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 conftestfile 2> /dev/null`

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

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

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

# -L didn't work.

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

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

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

rm -f conftest.file

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

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

&& 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 979

Line 293

alias in your environment])

test "[$]2" = conftestfile

test "$[2]" = conftest.file

)

then

# Ok.

Line 988

Line 302

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

Check your system clock])

rm -f conftest*

AC_MSG_RESULT(yes)])

dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)

# -*- Autoconf -*-

dnl The program must properly implement --version.

AC_DEFUN([AM_MISSING_PROG],

[AC_MSG_CHECKING(for working $2)

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

# 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

$1=$2

AC_MSG_RESULT(found)

else

$1="$3/missing $2"

AC_MSG_RESULT(missing)

AC_SUBST($1)])

# Like AC_CONFIG_HEADER, but automatically create stamp file.

AC_DEFUN([AM_CONFIG_HEADER],

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

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

# AC_PROG_LIBTOOL

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

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

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

AC_DEFUN([AC_PROG_LIBTOOL],

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

[AC_REQUIRE([_AC_PROG_LIBTOOL])dnl

# GNU General Public License for more details.

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

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

LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

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

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

# 02111-1307, USA.

# Always use our own libtool.

# serial 3

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

AC_SUBST(LIBTOOL)dnl

# Prevent multiple expansion

# AM_MISSING_PROG(NAME, PROGRAM)

define([AC_PROG_LIBTOOL], [])

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

])# _AC_PROG_LIBTOOL

AC_DEFUN([AM_MISSING_PROG],

[AC_REQUIRE([AM_MISSING_HAS_RUN])

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

AC_SUBST($1)])

# AC_LIBTOOL_SETUP

# AM_MISSING_HAS_RUN

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

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

AC_DEFUN([AC_LIBTOOL_SETUP],

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

[AC_PREREQ(2.50)dnl

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

AC_REQUIRE([AC_ENABLE_SHARED])dnl

AC_DEFUN([AM_MISSING_HAS_RUN],

AC_REQUIRE([AC_ENABLE_STATIC])dnl

[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

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

AC_REQUIRE([AC_CANONICAL_HOST])dnl

# Use eval to expand $SHELL

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

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

AC_REQUIRE([AC_PROG_CC])dnl

am_missing_run="$MISSING --run "

AC_REQUIRE([AC_PROG_LD])dnl

else

AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl

am_missing_run=

AC_REQUIRE([AC_PROG_NM])dnl

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

])

AC_REQUIRE([AC_PROG_LN_S])dnl

# AM_AUX_DIR_EXPAND

AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

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

AC_REQUIRE([AC_OBJEXT])dnl

AC_REQUIRE([AC_EXEEXT])dnl

dnl

AC_LIBTOOL_SYS_MAX_CMD_LEN

AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

AC_LIBTOOL_OBJDIR

AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

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

_LT_AC_PROG_ECHO_BACKSLASH

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

case $host_os in

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

aix3*)

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# reason, if we set the COLLECT_NAMES environment variable, the problems

# GNU General Public License for more details.

# vanish in a puff of smoke.

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

COLLECT_NAMES=

export COLLECT_NAMES

;;

esac

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

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

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

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

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

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

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

# 02111-1307, USA.

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

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

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

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

# Sed substitution to delay expansion of an escaped shell variable in a

# Rely on autoconf to set up CDPATH properly.

# double_quote_subst'ed string.

AC_PREREQ([2.50])

delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

# Sed substitution to avoid accidental globbing in evaled expressions

AC_DEFUN([AM_AUX_DIR_EXPAND], [

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

# expand $ac_aux_dir to an absolute path

am_aux_dir=`cd $ac_aux_dir && pwd`

])

# Constants:

# AM_PROG_INSTALL_SH

rm="rm -f"

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

# Define $install_sh.

# Global variables:

default_ofile=libtool

can_build_shared=yes

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

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

# which needs '.lib').

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

libext=a

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

ltmain="$ac_aux_dir/ltmain.sh"

# any later version.

ofile="$default_ofile"

with_gnu_ld="$lt_cv_prog_gnu_ld"

AC_CHECK_TOOL(AR, ar, false)

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

AC_CHECK_TOOL(RANLIB, ranlib, :)

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

AC_CHECK_TOOL(STRIP, strip, :)

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

old_CC="$CC"

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

old_CFLAGS="$CFLAGS"

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

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

# 02111-1307, USA.

# Set sane defaults for various variables

AC_DEFUN([AM_PROG_INSTALL_SH],

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

[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

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

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

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

AC_SUBST(install_sh)])

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.

# AM_PROG_INSTALL_STRIP

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

old_postinstall_cmds='chmod 644 $oldlib'

old_postuninstall_cmds=

if test -n "$RANLIB"; then

case $host_os in

openbsd*)

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

;;

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

;;

esac

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

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

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

case $deplibs_check_method in

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

file_magic*)

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

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

# any later version.

AC_PATH_MAGIC

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

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

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

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

esac

AC_SUBST([INSTALL_STRIP_PROGRAM])])

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

# serial 4 -*- Autoconf -*-

AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

enable_win32_dll=yes, enable_win32_dll=no)

AC_ARG_ENABLE([libtool-lock],

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

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

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

AC_ARG_WITH([pic],

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

[AC_HELP_STRING([--with-pic],

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

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

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

[pic_mode="$withval"],

# any later version.

[pic_mode=default])

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

# Use C for the default configuration in the libtool script

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

tagname=

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

AC_LIBTOOL_LANG_C_CONFIG

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

_LT_AC_TAGCONFIG

# GNU General Public License for more details.

])# AC_LIBTOOL_SETUP

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

# _LT_AC_SYS_COMPILER

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

AC_DEFUN([_LT_AC_SYS_COMPILER],

[AC_REQUIRE([AC_PROG_CC])dnl

# If no C compiler was specified, use CC.

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

LTCC=${LTCC-"$CC"}

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

# Allow CC to be a program name with arguments.

compiler=$CC

])# _LT_AC_SYS_COMPILER

# _LT_AC_SYS_LIBPATH_AIX

# _AM_DEPENDENCIES(NAME)

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

# Links a minimal program and checks the executable

# See how the compiler implements dependency checking.

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

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

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

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

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

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

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

# to the aix ld manual.

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

AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],

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

[AC_LINK_IFELSE(AC_LANG_PROGRAM,[

# just rely on AC_PROG_CC.

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

AC_DEFUN([_AM_DEPENDENCIES],

}'`

[AC_REQUIRE([AM_SET_DEPDIR])dnl

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

AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl

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

AC_REQUIRE([AM_MAKE_INCLUDE])dnl

}'`; fi],[])

AC_REQUIRE([AM_DEP_TRACK])dnl

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

])# _LT_AC_SYS_LIBPATH_AIX

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"

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

rm -rf conftest.dir

else

am_cv_$1_dependencies_compiler_type=none

])

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

])

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

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

# Choose a directory name for dependency files.

# This macro is AC_REQUIREd in _AM_DEPENDENCIES

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

])

# _LT_AC_PROG_ECHO_BACKSLASH

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

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

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

AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],

[_LT_AC_SHELL_INIT([

# Check that we are running under the correct shell.

SHELL=${CONFIG_SHELL-/bin/sh}

case X$ECHO in

# AM_DEP_TRACK

X*--fallback-echo)

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

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

AC_DEFUN([AM_DEP_TRACK],

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

[AC_ARG_ENABLE(dependency-tracking,

;;

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

esac

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

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

echo=${ECHO-echo}

am_depcomp="$ac_aux_dir/depcomp"

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

AMDEPBACKSLASH='\'

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

shift

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

# Avoid inline document here, it may be left over

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

# Yippee, $echo works!

else

# Restart under the correct shell.

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

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

AC_SUBST([AMDEPBACKSLASH])

])

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

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

# used as fallback echo

shift

cat <<EOF

[$]*

EOF

exit 0

# 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

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

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

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

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

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

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

# any later version.

# 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

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

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

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

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

else

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

# backslashes. This makes it impossible to quote backslashes using

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

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

lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

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

for dir in $PATH /usr/ucb; do

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

IFS="$lt_save_ifs"

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

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

# 02111-1307, USA.

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"

if test "X$echo" = Xecho; then

#serial 2

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

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

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

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

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

echo='print -r'

elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&

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

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

ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

export ORIGINAL_CONFIG_SHELL

CONFIG_SHELL=/bin/ksh

export CONFIG_SHELL

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

else

# Try using printf.

echo='printf %s\n'

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

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

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

# Cool, printf works

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

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

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

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

CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL

export CONFIG_SHELL

SHELL="$CONFIG_SHELL"

export SHELL

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

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

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

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

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

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

else

# maybe with a smaller string...

prev=:

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

# _AM_OUTPUT_DEPENDENCY_COMMANDS

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

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

then

AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],

break

[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

prev="$cmd"

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

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

echo_test_string=`eval $prev`

export echo_test_string

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

else

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

echo=echo

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

# AM_OUTPUT_DEPENDENCY_COMMANDS

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

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

ECHO=$echo

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

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

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

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

])

AC_SUBST(ECHO)

])])# _LT_AC_PROG_ECHO_BACKSLASH

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

# _LT_AC_LOCK

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

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

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

AC_DEFUN([_LT_AC_LOCK],

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

[AC_ARG_ENABLE([libtool-lock],

# GNU General Public License for more details.

[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

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

# libtool support.

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

case $host in

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

ia64-*-hpux*)

# 02111-1307, USA.

# 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} -melf32bsmip"

;;

*N32*)

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

;;

*64-bit*)

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

;;

esac

else

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

*32-bit*)

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

;;

*N32*)

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

;;

*64-bit*)

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

;;

esac

rm -rf conftest*

;;

x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)

# serial 2

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

;;

*-*-sco3.2v5*)

# AM_MAKE_INCLUDE()

# On SCO OpenServer 5, we need -belf to get full-featured binaries.

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

SAVE_CFLAGS="$CFLAGS"

# Check to see how make treats includes.

CFLAGS="$CFLAGS -belf"

AC_DEFUN([AM_MAKE_INCLUDE],

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

[am_make=${MAKE-make}

[AC_LANG_PUSH(C)

cat > confinc << 'END'

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

doit:

AC_LANG_POP])

@echo done

if test x"$lt_cv_cc_needs_belf" != x"yes"; then

END

# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf

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

CFLAGS="$SAVE_CFLAGS"

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

am__include="#"

;;

am__quote=

AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

_am_result=none

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

# First try GNU make style include.

AC_CHECK_TOOL(DLLTOOL, dlltool, false)

echo "include confinc" > confmf

AC_CHECK_TOOL(AS, as, false)

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

AC_CHECK_TOOL(OBJDUMP, objdump, false)

# 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

])

esac

need_locks="$enable_libtool_lock"

])# _LT_AC_LOCK

# AM_CONDITIONAL -*- Autoconf -*-

# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

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

$rm conftest*

])

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

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

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

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

else

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

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

# any later version.

])# AC_LIBTOOL_COMPILER_OPTION

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

# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

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

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

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

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

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

# Check whether the given compiler option works

# 02111-1307, USA.

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"

])

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

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

else

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

])# AC_LIBTOOL_LINKER_OPTION

# AC_LIBTOOL_SYS_MAX_CMD_LEN

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

AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],

[# find the maximum length of command line arguments

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

AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl

i=0

testring="ABCD"

case $build_os in

msdosdjgpp*)

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

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

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

# check would be larger than it should be.

lt_cv_sys_max_cmd_len=12288; # 12K is about right

;;

gnu*)

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

# no limit to the length of command line arguments.

# Libtool will interpret -1 as no limit whatsoever

lt_cv_sys_max_cmd_len=-1;

;;

cygwin* | mingw*)

# serial 5

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

# about 5 minutes as the teststring grows exponentially.

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

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

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

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

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

lt_cv_sys_max_cmd_len=8192;

;;

amigaos*)

AC_PREREQ(2.52)

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

;;

# AM_CONDITIONAL(NAME, SHELL-CONDITION)

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

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

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

# Define a conditional.

# we can't tell.

AC_DEFUN([AM_CONDITIONAL],

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

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

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

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

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

AC_SUBST([$1_TRUE])

lt_cv_sys_max_cmd_len=$new_result &&

AC_SUBST([$1_FALSE])

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

if $2; then

$1_TRUE=

i=`expr $i + 1`

$1_FALSE='#'

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 test -n $lt_cv_sys_max_cmd_len ; then

AC_MSG_RESULT($lt_cv_sys_max_cmd_len)

else

AC_MSG_RESULT(none)

$1_TRUE='#'

$1_FALSE=

])# AC_LIBTOOL_SYS_MAX_CMD_LEN

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

# _LT_AC_CHECK_DLFCN

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

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

AC_DEFUN([_LT_AC_CHECK_DLFCN],

[AC_CHECK_HEADERS(dlfcn.h)dnl

])# _LT_AC_CHECK_DLFCN

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

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

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

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

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

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

AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],

# any later version.

[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

if test "$cross_compiling" = yes; then :

[$4]

else

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"

#if HAVE_DLFCN_H

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

#include <dlfcn.h>

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

#endif

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#include <stdio.h>

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

#ifdef RTLD_GLOBAL

AC_PREREQ([2.52])

# 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

# serial 6

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

#ifndef LT_DLLAZY_OR_NOW

# ifdef RTLD_LAZY

# define LT_DLLAZY_OR_NOW RTLD_LAZY

# else

# ifdef DL_LAZY

# define LT_DLLAZY_OR_NOW DL_LAZY

# else

# ifdef RTLD_NOW

# 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

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

extern "C" void exit (int);

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

#endif

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

# and everything past the last "/".

void fnord() { int i=42;}

# _AM_DIRNAME(PATH)

int main ()

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

{

# Like AS_DIRNAME, only do it during macro expansion

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

AC_DEFUN([_AM_DIRNAME],

int status = $lt_dlunknown;

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

if (self)

{

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

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

/* dlclose (self); */

}

exit (status);

# _AM_STAMP(HEADER)

}]

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

EOF

# The name of the stamp file for HEADER.

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

AC_DEFUN([_AM_STAMP],

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

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

lt_status=$?

AS_ESCAPE(_AM_DIRNAME(patsubst([$1],

case x$lt_status in

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

x$lt_dlno_uscore) $1 ;;

x$lt_dlneed_uscore) $2 ;;

x$lt_unknown|x*) $3 ;;

esac

else :

# compilation failed

rm -fr conftest*

])# _LT_AC_TRY_DLOPEN_SELF

# AC_LIBTOOL_DLOPEN_SELF

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

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

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

AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],

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

[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

# that will cause unnecessary cvs conflicts.

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

AC_DEFUN([_AM_CONFIG_HEADER],

enable_dlopen=unknown

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

enable_dlopen_self=unknown

# along with our hook.

enable_dlopen_self_static=unknown

AC_CONFIG_HEADERS([$1],

else

[# update the timestamp

lt_cv_dlopen=no

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

lt_cv_dlopen_libs=

$2],

[$3])

])# _AM_CONFIG_HEADER

case $host_os in

beos*)

lt_cv_dlopen="load_add_on"

lt_cv_dlopen_libs=

lt_cv_dlopen_self=yes

;;

mingw* | pw32*)

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

lt_cv_dlopen="LoadLibrary"

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

lt_cv_dlopen_libs=

AC_DEFUN([AM_CONFIG_HEADER],

;;

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

])# AM_CONFIG_HEADER

cygwin*)

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

lt_cv_dlopen="dlopen"

lt_cv_dlopen_libs=

;;

darwin*)

# serial 46 AC_PROG_LIBTOOL

# 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

])

;;

AC_DEFUN([AC_PROG_LIBTOOL],

AC_CHECK_FUNC([shl_load],

[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl

[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

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

# This can be used to rebuild libtool when needed

enable_dlopen=yes

LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

else

enable_dlopen=no

case $lt_cv_dlopen in

# Always use our own libtool.

dlopen)

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

save_CPPFLAGS="$CPPFLAGS"

AC_SUBST(LIBTOOL)dnl

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

save_LDFLAGS="$LDFLAGS"

# Prevent multiple expansion

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

define([AC_PROG_LIBTOOL], [])

])

save_LIBS="$LIBS"

AC_DEFUN([AC_LIBTOOL_SETUP],

LIBS="$lt_cv_dlopen_libs $LIBS"

[AC_PREREQ(2.13)dnl

AC_REQUIRE([AC_ENABLE_SHARED])dnl

AC_REQUIRE([AC_ENABLE_STATIC])dnl

AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

AC_REQUIRE([AC_CANONICAL_HOST])dnl

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_PROG_LD])dnl

AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl

AC_REQUIRE([AC_PROG_NM])dnl

AC_REQUIRE([LT_AC_PROG_SED])dnl

AC_CACHE_CHECK([whether a program can dlopen itself],

AC_REQUIRE([AC_PROG_LN_S])dnl

lt_cv_dlopen_self, [dnl

AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

_LT_AC_TRY_DLOPEN_SELF(

AC_REQUIRE([AC_OBJEXT])dnl

lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,

AC_REQUIRE([AC_EXEEXT])dnl

lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)

dnl

])

if test "x$lt_cv_dlopen_self" = xyes; then

_LT_AC_PROG_ECHO_BACKSLASH

LDFLAGS="$LDFLAGS $link_static_flag"

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

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

case $deplibs_check_method in

lt_cv_dlopen_self_static, [dnl

file_magic*)

_LT_AC_TRY_DLOPEN_SELF(

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

lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,

AC_PATH_MAGIC

lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross)

])

CPPFLAGS="$save_CPPFLAGS"

LDFLAGS="$save_LDFLAGS"

LIBS="$save_LIBS"

;;

esac

case $lt_cv_dlopen_self in

AC_CHECK_TOOL(RANLIB, ranlib, :)

yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

AC_CHECK_TOOL(STRIP, strip, :)

*) enable_dlopen_self=unknown ;;

esac

case $lt_cv_dlopen_self_static in

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

yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],

*) enable_dlopen_self_static=unknown ;;

enable_win32_dll=yes, enable_win32_dll=no)

esac

])# AC_LIBTOOL_DLOPEN_SELF

# AC_LIBTOOL_PROG_CC_C_O([TAGNAME])

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

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

AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],

[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

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

[_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],

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

AC_ARG_ENABLE(libtool-lock,

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

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

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

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

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

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

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

# libtool support.

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

case $host in

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

*-*-irix6*)

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

# Find out which ABI we are using.

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

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

-e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \

if AC_TRY_EVAL(ac_compile); then

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

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

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

*32-bit*)

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

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

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

;;

ac_status=$?

*N32*)

cat out/conftest.err >&AS_MESSAGE_LOG_FD

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

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

;;

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

*64-bit*)

then

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

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

;;

# So say no if there are warnings

esac

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

_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

rm -rf conftest*

;;

*-*-sco3.2v5*)

# On SCO OpenServer 5, we need -belf to get full-featured binaries.

SAVE_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS -belf"

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

[AC_LANG_SAVE

AC_LANG_C

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

AC_LANG_RESTORE])

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"

chmod u+w .

;;

$rm conftest*

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

ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],

# template instantiation

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

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

AC_CHECK_TOOL(DLLTOOL, dlltool, false)

$rm out/* && rmdir out

AC_CHECK_TOOL(AS, as, false)

cd ..

AC_CHECK_TOOL(OBJDUMP, objdump, false)

rmdir conftest

$rm conftest*

# 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

;;

])

])# AC_LIBTOOL_PROG_CC_C_O

esac

_LT_AC_LTCONFIG_HACK

# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])

])

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

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

# AC_LIBTOOL_HEADER_ASSERT

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

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

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

hard_links=yes

[lt_cv_func_assert_works],

$rm conftest*

[case $host in

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

*-*-solaris*)

touch conftest.a

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

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

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

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

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

AC_MSG_RESULT([$hard_links])

*) lt_cv_func_assert_works=yes ;;

if test "$hard_links" = no; then

esac

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

need_locks=warn

else

;;

need_locks=no

esac])

if test "x$lt_cv_func_assert_works" = xyes; then

AC_CHECK_HEADERS(assert.h)

])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS

])# AC_LIBTOOL_HEADER_ASSERT

# _LT_AC_CHECK_DLFCN

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

AC_DEFUN([_LT_AC_CHECK_DLFCN],

[AC_CHECK_HEADERS(dlfcn.h)

])# _LT_AC_CHECK_DLFCN

# AC_LIBTOOL_OBJDIR

# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

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

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

AC_DEFUN([AC_LIBTOOL_OBJDIR],

AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],

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

[AC_REQUIRE([AC_CANONICAL_HOST])

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

AC_REQUIRE([AC_PROG_NM])

mkdir .libs 2>/dev/null

AC_REQUIRE([AC_OBJEXT])

if test -d .libs; then

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

lt_cv_objdir=.libs

AC_MSG_CHECKING([command to parse $NM output])

else

AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [dnl

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

lt_cv_objdir=_libs

rmdir .libs 2>/dev/null])

objdir=$lt_cv_objdir

])# AC_LIBTOOL_OBJDIR

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

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

# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])

# Character class describing NM global symbol codes.

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

symcode='[[BCDEGRST]]'

# Check hardcoding attributes.

AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],

[AC_MSG_CHECKING([how to hardcode library paths into programs])

_LT_AC_TAGVAR(hardcode_action, $1)=

if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \

test -n "$_LT_AC_TAGVAR(runpath_var $1)" || \

test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)"="Xyes" ; then

# We can hardcode non-existant directories.

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

if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&

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

# If the only mechanism to avoid hardcoding is shlibpath_var, we

# 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

# We can link without hardcoding, and we can hardcode nonexisting dirs.

_LT_AC_TAGVAR(hardcode_action, $1)=immediate

else

# We cannot hardcode anything, or else we can only hardcode existing

# directories.

_LT_AC_TAGVAR(hardcode_action, $1)=unsupported

AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])

if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink; then

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

# Fast installation is not supported

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

enable_fast_install=no

elif test "$shlibpath_overrides_runpath" = yes ||

test "$enable_shared" = no; then

# Fast installation is not necessary

enable_fast_install=needless

])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH

# Transform an extracted symbol line into a proper C declaration

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

# AC_LIBTOOL_SYS_LIB_STRIP

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

AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],

[striplib=

# Define system-specific variables.

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

# FIXME - insert some real tests, host_os isn't really good enough

case $host_os in

darwin*)

aix*)

if test -n "$STRIP" ; then

symcode='[[BCDT]]'

striplib="$STRIP -x"

AC_MSG_RESULT([yes])

else

AC_MSG_RESULT([no])

;;

cygwin* | mingw* | pw32*)

AC_MSG_RESULT([no])

symcode='[[ABCDGISTW]]'

;;

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

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

;;

irix* | nonstopux*)

symcode='[[BCDEGRST]]'

;;

osf*)

symcode='[[BCDEGQRST]]'

;;

solaris* | sysv5*)

symcode='[[BDT]]'

;;

sysv4)

symcode='[[DFNSTU]]'

;;

esac

])# AC_LIBTOOL_SYS_LIB_STRIP

# Handle CRLF in mingw tool chain

opt_cr=

case $host_os in

mingw*)

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

;;

esac

# AC_LIBTOOL_SYS_DYNAMIC_LINKER

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

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

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

# PORTME Fill in your ld.so characteristics

symcode='[[ABCDGISTW]]'

AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],

[AC_MSG_CHECKING([dynamic linker characteristics])

library_names_spec=

libname_spec='lib$name'

soname_spec=

shrext=".so"

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"

if test "$GCC" = yes; then

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 ';' >/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

# when you set need_version to no, make sure it does not cause -set_version

# Try without a prefix undercore, then with it.

# flags to be left without arguments

for ac_symprfx in "" "_"; do

need_version=unknown

case $host_os in

# Write the raw and C identifiers.

aix3*)

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

version_type=linux

library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

shlibpath_var=LIBPATH

# AIX 3 has no versioning support, so we append a major version to the name.

# Check to see that the pipe works correctly.

soname_spec='${libname}${release}${shared_ext}$major'

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

aix4* | aix5*)

if AC_TRY_EVAL(ac_compile); then

version_type=linux

# Now try to grab the symbols.

need_lib_prefix=no

nlist=conftest.nm

need_version=no

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

hardcode_into_libs=yes

# Try sorting and uniquifying the output.

if test "$host_cpu" = ia64; then

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

# AIX 5 supports IA64

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

library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

shlibpath_var=LD_LIBRARY_PATH

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

rm -f "$nlist"T

;;

esac

# AIX (on Power*) has no versioning support, so currently we can not hardcode correct

# 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

;;

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

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

library_names_spec='${libname}${shared_ext}'

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

dynamic_linker="$host_os ld.so"

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

shlibpath_var=LIBRARY_PATH

cat <<EOF > conftest.$ac_ext

;;

#ifdef __cplusplus

extern "C" {

bsdi4*)

#endif

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

EOF

version_type=windows

# Now generate the symbol file.

shrext=".dll"

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

need_version=no

need_lib_prefix=no

case $GCC,$host_os in

cat <<EOF >> conftest.$ac_ext

yes,cygwin* | yes,mingw* | yes,pw32*)

#if defined (__STDC__) && __STDC__

library_names_spec='$libname.dll.a'

# define lt_ptr void *

# DLL is installed to $(libdir)/../bin by postinstall_cmds

#else

postinstall_cmds='base_file=`basename \${file}`~

# define lt_ptr char *

dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

# define const

dldir=$destdir/`dirname \$dlpath`~

#endif

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

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

cygwin*)

const struct {

# Cygwin DLLs use 'cyg' prefix rather than 'lib'

const char *name;

soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

lt_ptr address;

sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

}

;;

lt_preloaded_symbols[[]] =

mingw*)

{

# MinGW DLLs use traditional 'lib' prefix

EOF

soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

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

sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

cat <<\EOF >> conftest.$ac_ext

if echo "$sys_lib_search_path_spec" | [grep ';[c-zC-Z]:/' >/dev/null]; then

{0, (lt_ptr) 0}

# 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

;;

#ifdef __cplusplus

library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'

}

;;

#endif

esac

EOF

dynamic_linker='Win32 ld.exe'

# Now try linking the two files.

# FIXME: first we should search . and the directory the executable is in

mv conftest.$ac_objext conftstm.$ac_objext

shlibpath_var=PATH

save_LIBS="$LIBS"

;;

save_CFLAGS="$CFLAGS"

LIBS="conftstm.$ac_objext"

CFLAGS="$CFLAGS$no_builtin_flag"

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

pipe_works=yes

LIBS="$save_LIBS"

CFLAGS="$save_CFLAGS"

else

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

else

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

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*

darwin* | rhapsody*)

# Do not use the global_symbol_pipe unless it works.

dynamic_linker="$host_os dyld"

if test "$pipe_works" = yes; then

version_type=darwin

break

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

sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

lt_cv_sys_global_symbol_pipe=

sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

done

;;

])

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

dgux*)

# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

version_type=linux

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

need_lib_prefix=no

AC_DEFUN([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],

need_version=no

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

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

# DJGPP uses `;' like DOS.

soname_spec='${libname}${release}${shared_ext}$major'

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

shlibpath_var=LD_LIBRARY_PATH

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

;;

case X$UNAME in

*-DOS) lt_cv_sys_path_separator=';' ;;

*) lt_cv_sys_path_separator=':' ;;

esac

PATH_SEPARATOR=$lt_cv_sys_path_separator

])# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

freebsd1*)

# _LT_AC_PROG_ECHO_BACKSLASH

dynamic_linker=no

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

;;

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

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

[AC_DIVERT_PUSH(NOTICE)])

_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

kfreebsd*-gnu)

# Check that we are running under the correct shell.

version_type=linux

SHELL=${CONFIG_SHELL-/bin/sh}

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'

;;

freebsd*)

case X$ECHO in

objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`

X*--fallback-echo)

version_type=freebsd-$objformat

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

case $version_type in

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

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 $host_os in

freebsd2*)

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

;;

gnu*)

echo=${ECHO-echo}

version_type=linux

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

need_lib_prefix=no

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

need_version=no

shift

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

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

soname_spec='${libname}${release}${shared_ext}$major'

# Avoid inline document here, it may be left over

shlibpath_var=LD_LIBRARY_PATH

hardcode_into_libs=yes

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

;;

# Yippee, $echo works!

hpux9* | hpux10* | hpux11*)

# 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

sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

# Restart under the correct shell.

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

sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

;;

hppa*64*)

shrext='.sl'

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

nonstopux*) version_type=nonstopux ;;

if test "$lt_cv_prog_gnu_ld" = yes; then

version_type=linux

else

version_type=irix

fi ;;

esac

need_lib_prefix=no

need_version=no

soname_spec='${libname}${release}${shared_ext}$major'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

case $host_os in

irix5* | nonstopux*)

libsuff= shlibsuff=

;;

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

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

;;

# No shared lib support for Linux oldld, aout, or coff.

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

linux*oldld* | linux*aout* | linux*coff*)

# used as fallback echo

dynamic_linker=no

shift

;;

cat <<EOF

EOF

exit 0

# This must be Linux ELF.

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

linux*)

# if CDPATH is set.

version_type=linux

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

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'

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 -z "$ECHO"; then

if test -f /etc/ld.so.conf; then

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

ld_extra=`$SED -e 's/[:,\t]/ /g;s/=[^=]*$//;s/=[^= ]* / /g' /etc/ld.so.conf`

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

sys_lib_dlsearch_path_spec="/lib /usr/lib $ld_extra"

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

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

;;

knetbsd*-gnu)

version_type=linux

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'

;;

netbsd*)

version_type=sunos

need_lib_prefix=no

need_version=no

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

dynamic_linker='NetBSD (a.out) ld.so'

else

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} ${libname}${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

dynamic_linker='NetBSD ld.elf_so'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

hardcode_into_libs=yes

;;

newsos6)

version_type=linux

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

;;

nto-qnx*)

version_type=linux

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

;;

openbsd*)

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

version_type=sunos

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

need_lib_prefix=no

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

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

;;

shlibpath_overrides_runpath=yes

;;

esac

else

shlibpath_overrides_runpath=yes

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

# backslashes. This makes it impossible to quote backslashes using

;;

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

os2*)

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

libname_spec='$name'

shrext=".dll"

need_lib_prefix=no

library_names_spec='$libname${shared_ext} $libname.a'

dynamic_linker='OS/2 ld.exe'

shlibpath_var=LIBPATH

;;

osf3* | osf4* | osf5*)

version_type=osf

need_lib_prefix=no

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

version_type=osf

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

;;

solaris*)

version_type=linux

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

hardcode_into_libs=yes

# ldd complains unless libraries are executable

postinstall_cmds='chmod +x $lib'

;;

sunos4*)

version_type=sunos

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

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

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

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)

need_lib_prefix=no

;;

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

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

if test -d /usr/nec ;then

for dir in $PATH /usr/ucb; do

version_type=linux

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

library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

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

soname_spec='$libname${shared_ext}.$major'

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

shlibpath_var=LD_LIBRARY_PATH

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

echo="$dir/echo"

break

;;

done

IFS="$save_ifs"

uts4*)

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

;;

dynamic_linker=no

;;

esac

AC_MSG_RESULT([$dynamic_linker])

test "$dynamic_linker" = no && can_build_shared=no

])# AC_LIBTOOL_SYS_DYNAMIC_LINKER

# _LT_AC_TAGCONFIG

if test "X$echo" = Xecho; then

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

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

AC_DEFUN([_LT_AC_TAGCONFIG],

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

[AC_ARG_WITH([tags],

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

[AC_HELP_STRING([--with-tags@<:@=TAGS@:>@],

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

[include additional configurations @<:@automatic@:>@])],

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

[tagnames="$withval"])

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

if test -f "$ltmain" && test -n "$tagnames"; then

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

if test ! -f "${ofile}"; then

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

AC_MSG_WARN([output file `$ofile' does not exist])

then

break

prev="$cmd"

done

if test -z "$LTCC"; then

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

eval "`$SHELL ${ofile} --config | grep '^LTCC='`"

echo_test_string=`eval $prev`

if test -z "$LTCC"; then

export echo_test_string

AC_MSG_WARN([output file `$ofile' does not look like a libtool script])

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

else

AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile'])

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

echo=echo

# Extract list of available tagged configurations in $ofile.

# Note that this assumes the entire list is on one line.

available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=$.*$$/\1/' -e 's/\"//g'`

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

if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null

then

AC_MSG_ERROR([tag name \"$tagname\" already exists])

# Update the list of available tags.

if test -n "$tagname"; then

echo appending configuration tag \"$tagname\" to $ofile

case $tagname in

CXX)

if test -n "$CXX" && test "X$CXX" != "Xno"; then

AC_LIBTOOL_LANG_CXX_CONFIG

else

tagname=""

;;

F77)

if test -n "$F77" && test "X$F77" != "Xno"; then

AC_LIBTOOL_LANG_F77_CONFIG

else

tagname=""

;;

GCJ)

if test -n "$GCJ" && test "X$GCJ" != "Xno"; then

AC_LIBTOOL_LANG_GCJ_CONFIG

else

tagname=""

;;

RC)

AC_LIBTOOL_LANG_RC_CONFIG

;;

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

AC_MSG_ERROR([Unsupported tag name: $tagname])

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

;;

ECHO=$echo

esac

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

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

# Append the new tag name to the list of available tags.

if test -n "$tagname" ; then

available_tags="$available_tags $tagname"

done

IFS="$lt_save_ifs"

# Now substitute the updated list of available tags.

AC_SUBST(ECHO)

if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then

AC_DIVERT_POP

mv "${ofile}T" "$ofile"

])# _LT_AC_PROG_ECHO_BACKSLASH

chmod +x "$ofile"

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

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

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

AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],

[if test "$cross_compiling" = yes; then :

[$4]

else

rm -f "${ofile}T"

AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

AC_MSG_ERROR([unable to update list of available tagged configurations.])

lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

lt_status=$lt_dlunknown

cat > conftest.$ac_ext <<EOF

])# _LT_AC_TAGCONFIG

[#line __oline__ "configure"

#include "confdefs.h"

#if HAVE_DLFCN_H

#include <dlfcn.h>

#endif

# AC_LIBTOOL_DLOPEN

#include <stdio.h>

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

# enable checks for dlopen support

AC_DEFUN([AC_LIBTOOL_DLOPEN],

[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])

])# AC_LIBTOOL_DLOPEN

#ifdef RTLD_GLOBAL

# define LT_DLGLOBAL RTLD_GLOBAL

#else

# ifdef DL_GLOBAL

# define LT_DLGLOBAL DL_GLOBAL

# else

# define LT_DLGLOBAL 0

# endif

#endif

# AC_LIBTOOL_WIN32_DLL

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

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

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

# declare package support for building win32 dll's

#ifndef LT_DLLAZY_OR_NOW

AC_DEFUN([AC_LIBTOOL_WIN32_DLL],

# ifdef RTLD_LAZY

[AC_BEFORE([$0], [AC_LIBTOOL_SETUP])

# define LT_DLLAZY_OR_NOW RTLD_LAZY

])# AC_LIBTOOL_WIN32_DLL

# else

# ifdef DL_LAZY

# define LT_DLLAZY_OR_NOW DL_LAZY

# else

# ifdef RTLD_NOW

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

# AC_ENABLE_SHARED([DEFAULT])

if (self)

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

{

# implement the --enable-shared flag

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

# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.

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

AC_DEFUN([AC_ENABLE_SHARED],

/* dlclose (self); */

[define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl

}

AC_ARG_ENABLE([shared],

[AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],

exit (status);

[build shared libraries @<:@default=]AC_ENABLE_SHARED_DEFAULT[@:>@])],

}]

[p=${PACKAGE-default}

EOF

case $enableval in

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

yes) enable_shared=yes ;;

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

no) enable_shared=no ;;

lt_status=$?

case x$lt_status in

enable_shared=no

x$lt_dlno_uscore) $1 ;;

# Look at the argument we got. We use all the common list separators.

x$lt_dlneed_uscore) $2 ;;

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

x$lt_unknown|x*) $3 ;;

for pkg in $enableval; do

esac

IFS="$lt_save_ifs"

else :

if test "X$pkg" = "X$p"; then

# compilation failed

enable_shared=yes

done

IFS="$lt_save_ifs"

rm -fr conftest*

;;

])# _LT_AC_TRY_DLOPEN_SELF

esac],

[enable_shared=]AC_ENABLE_SHARED_DEFAULT)

])# AC_ENABLE_SHARED

# AC_LIBTOOL_DLOPEN_SELF

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

AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],

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

enable_dlopen=unknown

enable_dlopen_self=unknown

enable_dlopen_self_static=unknown

else

lt_cv_dlopen=no

lt_cv_dlopen_libs=

# AC_DISABLE_SHARED

case $host_os in

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

beos*)

#- set the default shared flag to --disable-shared

lt_cv_dlopen="load_add_on"

AC_DEFUN([AC_DISABLE_SHARED],

lt_cv_dlopen_libs=

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

lt_cv_dlopen_self=yes

AC_ENABLE_SHARED(no)

;;

])# AC_DISABLE_SHARED

cygwin* | mingw* | pw32*)

lt_cv_dlopen="LoadLibrary"

lt_cv_dlopen_libs=

;;

# AC_ENABLE_STATIC([DEFAULT])

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

# implement the --enable-static flag

# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.

AC_DEFUN([AC_ENABLE_STATIC],

[define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl

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

AC_CHECK_FUNC([shl_load],

# Look at the argument we got. We use all the common list separators.

[lt_cv_dlopen="shl_load"],

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

[AC_CHECK_LIB([dld], [shl_load],

for pkg in $enableval; do

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

IFS="$lt_save_ifs"

[AC_CHECK_FUNC([dlopen],

if test "X$pkg" = "X$p"; then

[lt_cv_dlopen="dlopen"],

enable_static=yes

[AC_CHECK_LIB([dl], [dlopen],

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

done

[AC_CHECK_LIB([svld], [dlopen],

IFS="$lt_save_ifs"

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

esac

[enable_static=]AC_ENABLE_STATIC_DEFAULT)

])# AC_ENABLE_STATIC

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

enable_dlopen=yes

else

enable_dlopen=no

# AC_DISABLE_STATIC

case $lt_cv_dlopen in

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

dlopen)

# set the default static flag to --disable-static

save_CPPFLAGS="$CPPFLAGS"

AC_DEFUN([AC_DISABLE_STATIC],

AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

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

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

AC_ENABLE_STATIC(no)

])# AC_DISABLE_STATIC

save_LDFLAGS="$LDFLAGS"

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

# AC_ENABLE_FAST_INSTALL([DEFAULT])

save_LIBS="$LIBS"

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

LIBS="$lt_cv_dlopen_libs $LIBS"

# implement the --enable-fast-install flag

# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.

AC_CACHE_CHECK([whether a program can dlopen itself],

AC_DEFUN([AC_ENABLE_FAST_INSTALL],

lt_cv_dlopen_self, [dnl

[define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl

_LT_AC_TRY_DLOPEN_SELF(

AC_ARG_ENABLE([fast-install],

lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,

[AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],

lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)

[optimize for fast installation @<:@default=]AC_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],

])

[p=${PACKAGE-default}

case $enableval in

if test "x$lt_cv_dlopen_self" = xyes; then

yes) enable_fast_install=yes ;;

LDFLAGS="$LDFLAGS $link_static_flag"

no) enable_fast_install=no ;;

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

lt_cv_dlopen_self_static, [dnl

enable_fast_install=no

_LT_AC_TRY_DLOPEN_SELF(

# Look at the argument we got. We use all the common list separators.

lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross)

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"

CPPFLAGS="$save_CPPFLAGS"

LDFLAGS="$save_LDFLAGS"

LIBS="$save_LIBS"

;;

esac],

esac

[enable_fast_install=]AC_ENABLE_FAST_INSTALL_DEFAULT)

])# AC_ENABLE_FAST_INSTALL

case $lt_cv_dlopen_self in

yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

*) enable_dlopen_self=unknown ;;

esac

# AC_DISABLE_FAST_INSTALL

case $lt_cv_dlopen_self_static in

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

yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

# set the default to --disable-fast-install

*) enable_dlopen_self_static=unknown ;;

AC_DEFUN([AC_DISABLE_FAST_INSTALL],

esac

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

AC_ENABLE_FAST_INSTALL(no)

])# AC_LIBTOOL_DLOPEN_SELF

])# AC_DISABLE_FAST_INSTALL

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'

# AC_LIBTOOL_PICMODE([MODE])

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

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

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

# 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

# Sed substitution to delay expansion of an escaped shell variable in a

# double_quote_subst'ed string.

delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

# AC_PROG_EGREP

# Constants:

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

rm="rm -f"

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

])])

# Global variables:

default_ofile=libtool

can_build_shared=yes

# AC_PATH_TOOL_PREFIX

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

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

# which needs '.lib').

# find a file program which can recognise shared library

libext=a

AC_DEFUN([AC_PATH_TOOL_PREFIX],

ltmain="$ac_aux_dir/ltmain.sh"

[AC_REQUIRE([AC_PROG_EGREP])dnl

ofile="$default_ofile"

AC_MSG_CHECKING([for $1])

with_gnu_ld="$lt_cv_prog_gnu_ld"

AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,

need_locks="$enable_libtool_lock"

[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 command libtool uses to detect shared libraries,

old_CC="$CC"

*** $file_magic_cmd, produces output that libtool cannot recognize.

old_CFLAGS="$CFLAGS"

*** The result is that libtool may fail to recognize shared libraries

*** as such. This will affect the creation of libtool libraries that

*** depend on shared libraries, but programs linked with such libtool

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

# Set sane defaults for various variables

fi ;;

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

esac

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

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

test -z "$CC" && CC=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 "$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

ac_tool_prefix=${host_alias}-

else

ac_tool_prefix=

break

# Transform linux* to *-*-linux-gnu*, to support old configure scripts.

case $host_os in

linux-gnu*) ;;

linux*) host=`echo $host | sed 's/^$.*-.*-linux$$.*$$/\1-gnu\2/'`

esac

case $host_os in

aix3*)

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

# reason, if we set the COLLECT_NAMES environment variable, the problems

# vanish in a puff of smoke.

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

COLLECT_NAMES=

export COLLECT_NAMES

done

IFS="$lt_save_ifs"

MAGIC_CMD="$lt_save_MAGIC_CMD"

;;

esac])

esac

MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

if test -n "$MAGIC_CMD"; then

# Determine commands to create old-style static archives.

AC_MSG_RESULT($MAGIC_CMD)

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

else

old_postinstall_cmds='chmod 644 $oldlib'

AC_MSG_RESULT(no)

old_postuninstall_cmds=

if test -n "$RANLIB"; then

case $host_os in

openbsd*)

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

;;

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

;;

esac

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

])# AC_PATH_TOOL_PREFIX

# Allow CC to be a program name with arguments.

set dummy $CC

compiler="[$]2"

# AC_PATH_MAGIC

AC_MSG_CHECKING([for objdir])

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

rm -f .libs 2>/dev/null

# find a file program which can recognise a shared library

mkdir .libs 2>/dev/null

AC_DEFUN([AC_PATH_MAGIC],

if test -d .libs; then

[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)

objdir=.libs

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

MAGIC_CMD=:

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

objdir=_libs

])# AC_PATH_MAGIC

rmdir .libs 2>/dev/null

AC_MSG_RESULT($objdir)

# AC_PROG_LD

AC_ARG_WITH(pic,

# ----------

[ --with-pic try to use only PIC/non-PIC objects [default=use both]],

# find the pathname to the GNU or non-GNU linker

pic_mode="$withval", pic_mode=default)

AC_DEFUN([AC_PROG_LD],

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

[AC_ARG_WITH([gnu-ld],

[AC_HELP_STRING([--with-gnu-ld],

# We assume here that the value for lt_cv_prog_cc_pic will not be cached

[assume the C compiler uses GNU ld @<:@default=no@:>@])],

# in isolation, and that seeing it set (from the cache) indicates that

[test "$withval" = no || with_gnu_ld=yes],

# the associated values are set (in the cache) correctly too.

[with_gnu_ld=no])

AC_MSG_CHECKING([for $compiler option to produce PIC])

AC_REQUIRE([LT_AC_PROG_SED])dnl

AC_CACHE_VAL(lt_cv_prog_cc_pic,

AC_REQUIRE([AC_PROG_CC])dnl

[ lt_cv_prog_cc_pic=

AC_REQUIRE([AC_CANONICAL_HOST])dnl

lt_cv_prog_cc_shlib=

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

lt_cv_prog_cc_wl=

ac_prog=ld

lt_cv_prog_cc_static=

lt_cv_prog_cc_no_builtin=

lt_cv_prog_cc_can_build_shared=$can_build_shared

if test "$GCC" = yes; then

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

lt_cv_prog_cc_wl='-Wl,'

AC_MSG_CHECKING([for ld used by $CC])

lt_cv_prog_cc_static='-static'

case $host in

*-*-mingw*)

case $host_os in

# gcc leaves a trailing carriage return which upsets mingw

aix*)

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

# Below there is a dirty hack to force normal static linking with -ldl

# The problem is because libdl dynamically linked with both libc and

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

# libC (AIX C++ library), which obviously doesn't included in libraries

esac

# list by gcc. This cause undefined symbols with -static flags.

case $ac_prog in

# This hack allows C programs to be linked with "-static -ldl", but

# Accept absolute paths.

# not sure about C++ programs.

[[\\/]]* | ?:[[\\/]]*)

lt_cv_prog_cc_static="$lt_cv_prog_cc_static ${lt_cv_prog_cc_wl}-lC"

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"

;;

"")

amigaos*)

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

# FIXME: we need at least 68020 code to build shared libraries, but

ac_prog=ld

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

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

# PIC is the default for these OSes.

with_gnu_ld=unknown

;;

esac

darwin* | rhapsody*)

elif test "$with_gnu_ld" = yes; then

# PIC is the default on this platform

AC_MSG_CHECKING([for GNU ld])

# Common symbols not allowed in MH_DYLIB files

else

lt_cv_prog_cc_pic='-fno-common'

AC_MSG_CHECKING([for non-GNU ld])

;;

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'

;;

sysv4*MP*)

if test -d /usr/nec; then

lt_cv_prog_cc_pic=-Kconform_pic

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

lt_cv_prog_cc_pic='-fPIC'

;;

esac

done

IFS="$lt_save_ifs"

else

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

# PORTME Check for PIC flags for the system compiler.

fi])

case $host_os in

LD="$lt_cv_path_LD"

aix3* | aix4* | aix5*)

if test -n "$LD"; then

lt_cv_prog_cc_wl='-Wl,'

AC_MSG_RESULT($LD)

# All AIX code is PIC.

if test "$host_cpu" = ia64; then

# AIX 5 now supports IA64 processor

lt_cv_prog_cc_static='-Bstatic'

else

AC_MSG_RESULT(no)

lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'

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

AC_PROG_LD_GNU

])# AC_PROG_LD

# AC_PROG_LD_GNU

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

AC_DEFUN([AC_PROG_LD_GNU],

[AC_REQUIRE([AC_PROG_EGREP])dnl

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

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

case `$LD -v 2>&1 </dev/null` in

*GNU* | *'with BFD'*)

lt_cv_prog_gnu_ld=yes

;;

lt_cv_prog_gnu_ld=no

hpux9* | hpux10* | hpux11*)

# Is there a better lt_cv_prog_cc_static that works with the bundled CC?

lt_cv_prog_cc_wl='-Wl,'

lt_cv_prog_cc_static="${lt_cv_prog_cc_wl}-a ${lt_cv_prog_cc_wl}archive"

lt_cv_prog_cc_pic='+Z'

;;

esac])

with_gnu_ld=$lt_cv_prog_gnu_ld

])# AC_PROG_LD_GNU

irix5* | irix6* | nonstopux*)

lt_cv_prog_cc_wl='-Wl,'

lt_cv_prog_cc_static='-non_shared'

# PIC (with -KPIC) is the default.

;;

# AC_PROG_LD_RELOAD_FLAG

cygwin* | mingw* | pw32* | os2*)

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

# This hack is so that the source file can tell whether it is being

# find reload flag for linker

# built for inclusion in a dll (and should export symbols for example).

# -- PORTME Some linkers may need a different reload flag.

lt_cv_prog_cc_pic='-DDLL_EXPORT'

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

reload_cmds='$LD$reload_flag -o $output$reload_objs'

])# AC_PROG_LD_RELOAD_FLAG

newsos6)

lt_cv_prog_cc_pic='-KPIC'

lt_cv_prog_cc_static='-Bstatic'

;;

# AC_DEPLIBS_CHECK_METHOD

osf3* | osf4* | osf5*)

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

# All OSF/1 code is PIC.

# how to check for library dependencies

lt_cv_prog_cc_wl='-Wl,'

# -- PORTME fill in with the dynamic library characteristics

lt_cv_prog_cc_static='-non_shared'

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.

case $host_os in

sco3.2v5*)

aix4* | aix5*)

lt_cv_prog_cc_pic='-Kpic'

lt_cv_deplibs_check_method=pass_all

lt_cv_prog_cc_static='-dn'

lt_cv_prog_cc_shlib='-belf'

;;

beos*)

solaris*)

lt_cv_deplibs_check_method=pass_all

lt_cv_prog_cc_pic='-KPIC'

lt_cv_prog_cc_static='-Bstatic'

lt_cv_prog_cc_wl='-Wl,'

;;

bsdi4*)

sunos4*)

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'

lt_cv_prog_cc_pic='-PIC'

lt_cv_file_magic_cmd='/usr/bin/file -L'

lt_cv_prog_cc_static='-Bstatic'

lt_cv_file_magic_test_file=/shlib/libc.so

lt_cv_prog_cc_wl='-Qoption ld '

;;

cygwin*)

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

# win32_libid is a shell function defined in ltmain.sh

lt_cv_prog_cc_pic='-KPIC'

lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'

lt_cv_prog_cc_static='-Bstatic'

lt_cv_file_magic_cmd='win32_libid'

lt_cv_prog_cc_wl='-Wl,'

;;

mingw* | pw32*)

uts4*)

# Base MSYS/MinGW do not provide the 'file' command needed by

lt_cv_prog_cc_pic='-pic'

# win32_libid shell function, so use a weaker test based on 'objdump'.

lt_cv_prog_cc_static='-Bstatic'

lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'

lt_cv_file_magic_cmd='$OBJDUMP -f'

;;

darwin* | rhapsody*)

sysv4*MP*)

lt_cv_deplibs_check_method=pass_all

if test -d /usr/nec ;then

lt_cv_prog_cc_pic='-Kconform_pic'

lt_cv_prog_cc_static='-Bstatic'

;;

freebsd* | kfreebsd*-gnu)

if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

lt_cv_prog_cc_can_build_shared=no

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

else

lt_cv_deplibs_check_method=pass_all

;;

])

if test -z "$lt_cv_prog_cc_pic"; then

gnu*)

AC_MSG_RESULT([none])

lt_cv_deplibs_check_method=pass_all

else

;;

AC_MSG_RESULT([$lt_cv_prog_cc_pic])

hpux10.20* | hpux11*)

# Check to make sure the pic_flag actually works.

lt_cv_file_magic_cmd=/usr/bin/file

AC_MSG_CHECKING([if $compiler PIC flag $lt_cv_prog_cc_pic works])

case "$host_cpu" in

AC_CACHE_VAL(lt_cv_prog_cc_pic_works, [dnl

ia64*)

save_CFLAGS="$CFLAGS"

lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'

CFLAGS="$CFLAGS $lt_cv_prog_cc_pic -DPIC"

lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so

AC_TRY_COMPILE([], [], [dnl

;;

case $host_os in

hppa*64*)

hpux9* | hpux10* | hpux11*)

[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]']

# On HP-UX, both CC and GCC only warn that PIC is supported... then

lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl

# 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_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'

lt_cv_prog_cc_pic_works=yes

lt_cv_file_magic_test_file=/usr/lib/libc.sl

;;

esac

;;

], [dnl

lt_cv_prog_cc_pic_works=no

])

CFLAGS="$save_CFLAGS"

])

irix5* | irix6* | nonstopux*)

if test "X$lt_cv_prog_cc_pic_works" = Xno; then

case $LD in

lt_cv_prog_cc_pic=

*-32|*"-32 ") libmagic=32-bit;;

lt_cv_prog_cc_can_build_shared=no

*-n32|*"-n32 ") libmagic=N32;;

else

*-64|*"-64 ") libmagic=64-bit;;

lt_cv_prog_cc_pic=" $lt_cv_prog_cc_pic"

*) libmagic=never-match;;

esac

lt_cv_deplibs_check_method=pass_all

;;

# This must be Linux ELF.

AC_MSG_RESULT([$lt_cv_prog_cc_pic_works])

linux*)

lt_cv_deplibs_check_method=pass_all

;;

netbsd*)

# Check for any special shared library compilation flags.

if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

if test -n "$lt_cv_prog_cc_shlib"; then

lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'

AC_MSG_WARN([\`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries])

if echo "$old_CC $old_CFLAGS " | egrep -e "[[ ]]$lt_cv_prog_cc_shlib[[ ]]" >/dev/null; then :

else

lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'

AC_MSG_WARN([add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure])

lt_cv_prog_cc_can_build_shared=no

;;

newos6*)

AC_MSG_CHECKING([if $compiler static flag $lt_cv_prog_cc_static works])

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'

AC_CACHE_VAL([lt_cv_prog_cc_static_works], [dnl

lt_cv_file_magic_cmd=/usr/bin/file

lt_cv_prog_cc_static_works=no

lt_cv_file_magic_test_file=/usr/lib/libnls.so

save_LDFLAGS="$LDFLAGS"

;;

LDFLAGS="$LDFLAGS $lt_cv_prog_cc_static"

AC_TRY_LINK([], [], [lt_cv_prog_cc_static_works=yes])

LDFLAGS="$save_LDFLAGS"

])

nto-qnx*)

# Belt *and* braces to stop my trousers falling down:

lt_cv_deplibs_check_method=unknown

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"

openbsd*)

lt_cv_file_magic_cmd=/usr/bin/file

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

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`

AC_MSG_CHECKING([if $compiler supports -c -o file.$ac_objext])

if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

AC_CACHE_VAL([lt_cv_compiler_c_o], [

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'

$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_deplibs_check_method='file_magic OpenBSD.* shared library'

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

osf3* | osf4* | osf5*)

if test x"$compiler_c_o" = x"yes"; then

lt_cv_deplibs_check_method=pass_all

# Check to see if we can write to a .lo

;;

AC_MSG_CHECKING([if $compiler supports -c -o file.lo])

AC_CACHE_VAL([lt_cv_compiler_o_lo], [

lt_cv_compiler_o_lo=no

save_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS -c -o conftest.lo"

save_objext="$ac_objext"

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

])

ac_objext="$save_objext"

CFLAGS="$save_CFLAGS"

])

compiler_o_lo=$lt_cv_compiler_o_lo

AC_MSG_RESULT([$compiler_o_lo])

else

compiler_o_lo=no

sco3.2v5*)

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

lt_cv_deplibs_check_method=pass_all

hard_links="nottested"

;;

if test "$compiler_c_o" = 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

need_locks=no

solaris*)

if test "$GCC" = yes; then

lt_cv_deplibs_check_method=pass_all

# Check to see if options -fno-rtti -fno-exceptions are supported by compiler

;;

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"

compiler_rtti_exceptions=no

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

compiler_rtti_exceptions=no

else

compiler_rtti_exceptions=yes

])

CFLAGS="$save_CFLAGS"

AC_MSG_RESULT([$compiler_rtti_exceptions])

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

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

case $host_vendor in

no_builtin_flag=' -fno-builtin -fno-rtti -fno-exceptions'

motorola)

else

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

no_builtin_flag=' -fno-builtin'

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`

;;

ncr)

lt_cv_deplibs_check_method=pass_all

# See if the linker supports building shared libraries.

;;

AC_MSG_CHECKING([whether the linker ($LD) supports shared libraries])

sequent)

lt_cv_file_magic_cmd='/bin/file'

allow_undefined_flag=

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'

no_undefined_flag=

;;

need_lib_prefix=unknown

sni)

need_version=unknown

lt_cv_file_magic_cmd='/bin/file'

# when you set need_version to no, make sure it does not cause -set_version

lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"

# flags to be left without arguments

lt_cv_file_magic_test_file=/lib/libc.so

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

;;

siemens)

openbsd*)

lt_cv_deplibs_check_method=pass_all

with_gnu_ld=no

;;

esac

;;

sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*)

ld_shlibs=yes

lt_cv_deplibs_check_method=pass_all

if test "$with_gnu_ld" = yes; then

;;

# If archive_cmds runs LD, not CC, wlarc should be empty

esac

wlarc='${wl}'

])

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

# 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

# AC_PROG_NM

*** Warning: the GNU linker, at least up to release 2.9.1, is reported

# ----------

*** to be unable to reliably create shared libraries on AIX.

# find the pathname to a BSD-compatible name lister

*** Therefore, libtool is disabling shared libraries support. If you

AC_DEFUN([AC_PROG_NM],

*** really care for shared libraries, you may want to modify your PATH

[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,

*** so that a non-GNU linker is found, and then restart.

[if test -n "$NM"; then

# Let the user override the test.

EOF

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

;;

case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in

*/dev/null*)

lt_cv_path_NM="$tmp_nm -p"

break

;;

lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but

continue # so that we can try to find one that supports BSD flags

;;

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

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

# AC_CHECK_LIBM

# Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

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

# that the semantics of dynamic libraries on AmigaOS, at least up

# check for math library

# to version 4, is to share data among multiple programs linked

AC_DEFUN([AC_CHECK_LIBM],

# with the same dynamic library. Since this doesn't match the

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

# behavior of shared libraries on other platforms, we can use

LIBM=

# them.

case $host in

ld_shlibs=no

*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)

# These system don't have libm, or don't need it

;;

*-ncr-sysv4.3*)

AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")

beos*)

AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")

if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

allow_undefined_flag=unsupported

# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

# support --undefined. This deserves some investigation. FIXME

archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

else

ld_shlibs=no

;;

AC_CHECK_LIB(m, cos, LIBM="-lm")

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

])# AC_CHECK_LIBM

# mingw and cygwin differ, and it's simplest to just exclude the union

# of the two symbol sets.

dll_exclude_symbols=DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12,DllMainCRTStartup@12,DllEntryPoint@12

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

# can override, but on older systems we have to supply one (in ltdll.c)

if test "x$lt_cv_need_dllmain" = "xyes"; then

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'

# AC_LIBLTDL_CONVENIENCE([DIRECTORY])

# If the export-symbols file already is a .def file (1st line

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

# is EXPORTS), use it as is.

# sets LIBLTDL to the link flags for the libltdl convenience library and

# If DATA tags from a recent dlltool are present, honour them!

# LTDLINCL to the include flags for the libltdl header and adds

archive_expsym_cmds='if test "x`sed 1q $export_symbols`" = xEXPORTS; then

# --enable-ltdl-convenience to the configure arguments. Note that LIBLTDL

cp $export_symbols $output_objdir/$soname-def;

# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If

else

# DIRECTORY is not provided, it is assumed to be `libltdl'. LIBLTDL will

echo EXPORTS > $output_objdir/$soname-def;

# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed with

_lt_hint=1;

# '${top_srcdir}/' (note the single quotes!). If your package is not

cat $export_symbols | while read symbol; do

# flat and you're not using automake, define top_builddir and

set dummy \$symbol;

# top_srcdir appropriately in the Makefiles.

case \[$]# in

AC_DEFUN([AC_LIBLTDL_CONVENIENCE],

2) echo " \[$]2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;

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

4) echo " \[$]2 \[$]3 \[$]4 ; " >> $output_objdir/$soname-def; _lt_hint=`expr \$_lt_hint - 1`;;

case $enable_ltdl_convenience in

*) echo " \[$]2 @ \$_lt_hint \[$]3 ; " >> $output_objdir/$soname-def;;

no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;

esac;

"") enable_ltdl_convenience=yes

_lt_hint=`expr 1 + \$_lt_hint`;

ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;

done;

esac

fi~

LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la

'"$ltdll_cmds"'

LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])

$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~

# For backwards non-gettext consistent compatibility...

$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~

INCLTDL="$LTDLINCL"

$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~

])# AC_LIBLTDL_CONVENIENCE

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

;;

# AC_LIBLTDL_INSTALLABLE([DIRECTORY])

netbsd*)

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

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

# sets LIBLTDL to the link flags for the libltdl installable library and

archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

# LTDLINCL to the include flags for the libltdl header and adds

wlarc=

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

enable_ltdl_install=yes

])

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

ac_configure_args="$ac_configure_args --enable-ltdl-install=no"

archive_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

LIBLTDL="-lltdl"

archive_expsym_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

LTDLINCL=

# For backwards non-gettext consistent compatibility...

INCLTDL="$LTDLINCL"

])# AC_LIBLTDL_INSTALLABLE

# AC_LIBTOOL_CXX

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

# enable support for C++ libraries

AC_DEFUN([AC_LIBTOOL_CXX],

[AC_REQUIRE([_LT_AC_LANG_CXX])

])# AC_LIBTOOL_CXX

# _LT_AC_LANG_CXX

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

AC_DEFUN([_LT_AC_LANG_CXX],

[AC_REQUIRE([AC_PROG_CXX])

AC_REQUIRE([AC_PROG_CXXCPP])

_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX])

])# _LT_AC_LANG_CXX

# AC_LIBTOOL_F77

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

# enable support for Fortran 77 libraries

AC_DEFUN([AC_LIBTOOL_F77],

[AC_REQUIRE([_LT_AC_LANG_F77])

])# AC_LIBTOOL_F77

# _LT_AC_LANG_F77

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

AC_DEFUN([_LT_AC_LANG_F77],

[AC_REQUIRE([AC_PROG_F77])

_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}F77])

])# _LT_AC_LANG_F77

# 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

sco3.2v5*)

_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)='-belf'

;;

esac

if test -n "$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)"; then

AC_MSG_WARN([`$CC' requires `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to build shared libraries])

if echo "$old_CC $old_CFLAGS " | grep "[[ ]]$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)[[ ]]" >/dev/null; then :

else

AC_MSG_WARN([add `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to the CC or CFLAGS env variable and reconfigure])

_LT_AC_TAGVAR(lt_cv_prog_cc_can_build_shared, $1)=no

# Check to make sure the static flag actually works.

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

AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)

solaris* | sysv5*)

AC_LIBTOOL_PROG_COMPILER_PIC($1)

if $LD -v 2>&1 | egrep 'BFD 2\.8' > /dev/null; then

AC_LIBTOOL_PROG_CC_C_O($1)

ld_shlibs=no

AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

cat <<EOF 1>&2

AC_LIBTOOL_PROG_LD_SHLIBS($1)

AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

AC_LIBTOOL_SYS_LIB_STRIP

AC_LIBTOOL_DLOPEN_SELF($1)

# Report which librarie types wil actually be built

AC_MSG_CHECKING([if libtool supports shared libraries])

AC_MSG_RESULT([$can_build_shared])

AC_MSG_CHECKING([whether to build shared libraries])

*** Warning: The releases 2.8.* of the GNU linker cannot reliably

test "$can_build_shared" = "no" && enable_shared=no

*** create shared libraries on Solaris systems. Therefore, libtool

*** is disabling shared libraries support. We urge you to upgrade GNU

*** binutils to release 2.9.1 or newer. Another option is to modify

*** your PATH or compiler configuration so that the native linker is

*** used, and then restart.

# On AIX, shared libraries and static libraries use the same namespace, and

EOF

# are all built from PIC.

elif $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

case "$host_os" in

archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

aix3*)

archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

test "$enable_shared" = yes && enable_static=no

else

if test -n "$RANLIB"; then

ld_shlibs=no

archive_cmds="$archive_cmds~\$RANLIB \$lib"

postinstall_cmds='$RANLIB $lib'

;;

aix4*)

sunos4*)

if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

test "$enable_shared" = yes && enable_static=no

wlarc=

hardcode_direct=yes

;;

hardcode_shlibpath_var=no

darwin* | rhapsody*)

if test "$GCC" = yes; then

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

case "$host_os" in

rhapsody* | darwin1.[[012]])

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'

;;

*) # Darwin 1.3 on

if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

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

;;

10.*)

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'

;;

esac

;;

esac

output_verbose_link_cmd='echo'

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring'

if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

_LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

# Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's

archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

_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

ld_shlibs=no

;;

esac

AC_MSG_RESULT([$enable_shared])

AC_MSG_CHECKING([whether to build static libraries])

# Make sure either enable_shared or enable_static is yes.

test "$enable_shared" = yes || enable_static=yes

AC_MSG_RESULT([$enable_static])

AC_LIBTOOL_CONFIG($1)

AC_LANG_POP

CC="$lt_save_CC"

])# AC_LIBTOOL_LANG_C_CONFIG

# AC_LIBTOOL_LANG_CXX_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_CXX_CONFIG], [_LT_AC_LANG_CXX_CONFIG(CXX)])

AC_DEFUN([_LT_AC_LANG_CXX_CONFIG],

[AC_LANG_PUSH(C++)

AC_REQUIRE([AC_PROG_CXX])

AC_REQUIRE([AC_PROG_CXXCPP])

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

_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

# 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(int, char *[]) { return(0); }\n'

# ltmain only uses $CC for tagged configurations so make sure $CC is set.

_LT_AC_SYS_COMPILER

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

if test "$ld_shlibs" = yes; then

runpath_var=LD_RUN_PATH

hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir'

export_dynamic_flag_spec='${wl}--export-dynamic'

case $host_os in

cygwin* | mingw* | pw32*)

# dlltool doesn't understand --whole-archive et. al.

whole_archive_flag_spec=

;;

# ancient GNU ld didn't support --whole-archive et. al.

if eval "`$CC -print-prog-name=ld` --help 2>&1" | \

if $LD --help 2>&1 | egrep 'no-whole-archive' > /dev/null; then

grep 'no-whole-archive' > /dev/null; then

whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

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

whole_archive_flag_spec=

else

;;

with_gnu_ld=no

esac

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

# PORTME fill in a description of your system's linker (not GNU ld)

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

aix3*)

# FIXME: insert proper C++ library support

allow_undefined_flag=unsupported

_LT_AC_TAGVAR(ld_shlibs, $1)=no

always_export_symbols=yes

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'

# Note: this linker hardcodes the directories in LIBPATH if there

# 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

;;

aix4* | aix5*)

if test "$host_cpu" = ia64; then

# On IA64, the linker does run time linking by default, so we don't

Line 3785

Line 2327

# CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not

# enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

_LT_AC_TAGVAR(archive_cmds, $1)=''

hardcode_direct=yes

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

archive_cmds=''

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'

hardcode_libdir_separator=':'

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

if test "$GCC" = yes; then

case $host_os in aix4.[[012]]|aix4.[[012]].*)

if test "$GXX" = yes; then

case $host_os in aix4.[012]|aix4.[012].*)

# We only want to do this on AIX 4.2 and lower, the check

# below for broken collect2 doesn't work under 4.3+

collect2name=`${CC} -print-prog-name=collect2`

if test -f "$collect2name" && \

strings "$collect2name" | grep resolve_lib_name >/dev/null

then

# We have reworked collect2

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

hardcode_direct=yes

else

# We have old collect2

_LT_AC_TAGVAR(hardcode_direct, $1)=unsupported

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

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

hardcode_minus_L=yes

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

hardcode_libdir_flag_spec='-L$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

hardcode_libdir_separator=

esac

shared_flag='-shared'

else

# not using gcc

if test "$host_cpu" = ia64; then

# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

shared_flag='${wl}-G'

# chokes on -Wl,-G. The following line is correct:

shared_flag='-G'

else

if test "$aix_use_runtimelinking" = yes; then

shared_flag='${wl}-G'

Line 3827

Line 2364

# It seems that -bexpall does not export symbols beginning with

# It seems that -bexpall can do strange things, so it is better to

# underscore (_), so it is better to generate a list of symbols to export.

# generate a list of symbols to export.

_LT_AC_TAGVAR(always_export_symbols, $1)=yes

always_export_symbols=yes

if test "$aix_use_runtimelinking" = yes; then

# Warning - without using the other runtime loading flags (-brtl),

# -berok will link without error, but may produce a broken library.

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'

allow_undefined_flag='-berok'

# Determine the default libpath from the value encoded in an empty executable.

hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:/usr/lib:/lib'

_LT_AC_SYS_LIBPATH_AIX

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"

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$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

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'

hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'

_LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"

allow_undefined_flag="-z nodefs"

_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"

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

# Determine the default libpath from the value encoded in an empty executable.

hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'

_LT_AC_SYS_LIBPATH_AIX

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

# Warning - without using the other run time loading flags,

# -berok will link without error, but may produce a broken library.

_LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'

allow_undefined_flag='${wl}-berok'

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'

# This is a bit strange, but is similar to how AIX traditionally builds

# -bexpall does not export symbols beginning with underscore (_)

# it's shared libraries.

_LT_AC_TAGVAR(always_export_symbols, $1)=yes

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'

# Exported symbols can be pulled into shared objects from archives

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

# This is similar to how AIX traditionally builds it's shared libraries.

_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'

;;

chorus*)

case $cc_basename in

amigaos*)

# FIXME: insert proper C++ library support

hardcode_libdir_flag_spec='-L$libdir'

_LT_AC_TAGVAR(ld_shlibs, $1)=no

hardcode_minus_L=yes

;;

# see comment about different semantics on the GNU ld section

esac

ld_shlibs=no

;;

cygwin* | mingw* | pw32*)

# _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

# When not using gcc, we currently assume that we are using

# as there is no search path for DLLs.

# Microsoft Visual C++.

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

# hardcode_libdir_flag_spec is actually meaningless, as there is

_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

# no search path for DLLs.

_LT_AC_TAGVAR(always_export_symbols, $1)=no

hardcode_libdir_flag_spec=' '

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

allow_undefined_flag=unsupported

# Tell ltmain to make .lib files, not .a files.

if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

libext=lib

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'

# FIXME: Setting linknames here is a bad hack.

# If the export-symbols file already is a .def file (1st line

archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | sed -e '\''s/ -lc$//'\''` -link -dll~linknames='

# is EXPORTS), use it as is; otherwise, prepend...

# The linker will automatically build a .lib file if we build a DLL.

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

old_archive_from_new_cmds='true'

cp $export_symbols $output_objdir/$soname.def;

# FIXME: Should let the user specify the lib program.

else

old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs'

echo EXPORTS > $output_objdir/$soname.def;

fix_srcfile_path='`cygpath -w "$srcfile"`'

cat $export_symbols >> $output_objdir/$soname.def;

fi~

$CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'

else

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

darwin* | rhapsody*)

if test "$GXX" = yes; then

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

case "$host_os" in

rhapsody* | darwin1.[[012]])

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'

allow_undefined_flag='-undefined suppress'

;;

*) # Darwin 1.3 on

if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

allow_undefined_flag='-flat_namespace -undefined suppress'

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

;;

10.*)

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'

;;

esac

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

ld_shlibs=no

;;

# FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

# support. Future versions do this automatically, but an explicit c++rt0.o

# does not break anything, and helps significantly (at the cost of a little

# extra space).

freebsd2.2*)

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

hardcode_libdir_flag_spec='-R$libdir'

hardcode_direct=yes

hardcode_shlibpath_var=no

;;

# Unfortunately, older versions of FreeBSD 2 do not have this feature.

freebsd2*)

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

hardcode_direct=yes

hardcode_minus_L=yes

hardcode_shlibpath_var=no

;;

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

case $host_os 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' ;;

*) archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' ;;

esac

lt_int_apple_cc_single_mod=no

hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'

output_verbose_link_cmd='echo'

hardcode_libdir_separator=:

if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then

hardcode_direct=yes

lt_int_apple_cc_single_mod=yes

hardcode_minus_L=yes # Not in the search PATH, but as the default

# location of the library.

if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

export_dynamic_flag_spec='${wl}-E'

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

;;

else

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

_LT_AC_TAGVAR(module_cmds, $1)='$CC ${wl}-bind_at_load $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

irix5* | irix6* | nonstopux*)

if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

if test "$GCC" = yes; then

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^$..*$,_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

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'

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

else

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^$..*$,_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

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

_LT_AC_TAGVAR(hardcode_direct, $1)=no

link_all_deplibs=yes

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

netbsd*)

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out

else

_LT_AC_TAGVAR(ld_shlibs, $1)=no

archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF

hardcode_libdir_flag_spec='-R$libdir'

hardcode_direct=yes

hardcode_shlibpath_var=no

;;

dgux*)

newsos6)

case $cc_basename in

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

ec++)

hardcode_direct=yes

# FIXME: insert proper C++ library support

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(ld_shlibs, $1)=no

hardcode_libdir_separator=:

;;

hardcode_shlibpath_var=no

ghcx)

;;

# Green Hills C++ Compiler

# FIXME: insert proper C++ library support

openbsd*)

_LT_AC_TAGVAR(ld_shlibs, $1)=no

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'

;;

# FIXME: insert proper C++ library support

archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

_LT_AC_TAGVAR(ld_shlibs, $1)=no

hardcode_libdir_flag_spec='${wl}-rpath,$libdir'

;;

esac

;;

freebsd[12]*)

# C++ shared libraries reported to be fairly broken before switch to ELF

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

freebsd-elf*)

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

;;

freebsd* | kfreebsd*-gnu)

# FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF

# conventions

_LT_AC_TAGVAR(ld_shlibs, $1)=yes

;;

gnu*)

;;

hpux9*)

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,

# but as the default

# location of the library.

case $cc_basename in

os2*)

CC)

hardcode_libdir_flag_spec='-L$libdir'

# FIXME: insert proper C++ library support

hardcode_minus_L=yes

_LT_AC_TAGVAR(ld_shlibs, $1)=no

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'

aCC)

old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

# Commands to make compiler produce verbose output that lists

# what "hidden" libraries, object files and flags are used when

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | egrep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

;;

if test "$GXX" = yes; then

osf3*)

_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

if test "$GCC" = yes; then

allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'

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'

else

# FIXME: insert proper C++ library support

allow_undefined_flag=' -expect_unresolved \*'

_LT_AC_TAGVAR(ld_shlibs, $1)=no

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

;;

esac

;;

osf4* | osf5*) # as osf3* with the addition of -msym flag

hpux10*|hpux11*)

if test "$GCC" = yes; then

if test $with_gnu_ld = no; then

allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'

case "$host_cpu" in

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'

hppa*64*)

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

else

_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'

allow_undefined_flag=' -expect_unresolved \*'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

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

;;

ia64*)

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

sco3.2v5*)

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

export_dynamic_flag_spec='${wl}-Bexport'

;;

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

solaris*)

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

# gcc --version < 3.0 without binutils cannot create self contained

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

# 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

no_undefined_flag=

;;

esac

case "$host_cpu" in

# $CC -shared without GNU ld will not create a library from C++

hppa*64*)

# object files and a static libstdc++, better avoid it by now

_LT_AC_TAGVAR(hardcode_direct, $1)=no

archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

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'

ia64*)

hardcode_libdir_flag_spec='-R$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=no

hardcode_shlibpath_var=no

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

case $host_os in

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,

solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;

# but as the default

*) # Supported since Solaris 2.6 (maybe 2.5.1?)

# location of the library.

whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;

esac

link_all_deplibs=yes

;;

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

sunos4*)

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,

if test "x$host_vendor" = xsequent; then

# but as the default

# Use $CC to link under sequent, because it throws in some extra .o

# location of the library.

# 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

;;

esac

case $cc_basename in

sysv4)

CC)

case $host_vendor in

# FIXME: insert proper C++ library support

sni)

_LT_AC_TAGVAR(ld_shlibs, $1)=no

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

hardcode_direct=yes # is this really true???

;;

aCC)

siemens)

case "$host_cpu" in

## LD is ld it makes a PLAMLIB

hppa*64*|ia64*)

## CC just makes a GrossModule.

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'

archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'

reload_cmds='$CC -r -o $output$reload_objs'

hardcode_direct=no

;;

motorola)

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

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

# Commands to make compiler produce verbose output that lists

runpath_var='LD_RUN_PATH'

# what "hidden" libraries, object files and flags are used when

hardcode_shlibpath_var=no

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

;;

if test "$GXX" = yes; then

if test $with_gnu_ld = no; then

case "$host_cpu" in

ia64*|hppa*64*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'

;;

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

sysv4.3*)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

hardcode_shlibpath_var=no

export_dynamic_flag_spec='-Bexport'

;;

esac

sysv5*)

else

no_undefined_flag=' -z text'

# FIXME: insert proper C++ library support

# $CC -shared without GNU ld will not create a library from C++

_LT_AC_TAGVAR(ld_shlibs, $1)=no

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

;;

esac

uts4*)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

hardcode_libdir_flag_spec='-L$libdir'

hardcode_shlibpath_var=no

;;

irix5* | irix6*)

case $cc_basename in

CC)

# SGI C++

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'

# Archives containing C++ object files must be created using

dgux*)

# "CC -ar", where "CC" is the IRIX C++ compiler. This is

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

# necessary to make sure instantiated templates are included

hardcode_libdir_flag_spec='-L$libdir'

# in the archive.

hardcode_shlibpath_var=no

_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'

;;

if test "$GXX" = yes; then

if test "$with_gnu_ld" = no; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'

else

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

;;

esac

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

;;

linux*)

case $cc_basename in

KCC)

# Kuck and Associates, Inc. (KAI) C++ Compiler

# KCC will only create a shared library if the output file

# ends with ".so" (or ".sl" for HP-UX), so rename the library

# to its proper name (with version) after linking.

_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/$[[^()0-9A-Za-z{}]]$/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/$[[^()0-9A-Za-z{}]]$/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'

# Commands to make compiler produce verbose output that lists

# what "hidden" libraries, object files and flags are used when

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath,$libdir'

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

# Archives containing C++ object files must be created using

# "CC -Bstatic", where "CC" is the KAI C++ compiler.

_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'

;;

icpc)

# Intel C++

with_gnu_ld=yes

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $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,$libdir'

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'

;;

cxx)

# Compaq C++

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols'

sysv4*MP*)

if test -d /usr/nec; then

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

hardcode_shlibpath_var=no

runpath_var=LD_RUN_PATH

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

hardcode_runpath_var=yes

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

ld_shlibs=yes

# Commands to make compiler produce verbose output that lists

# what "hidden" libraries, object files and flags are used when

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/$^.*ld.*$$ .*ld .*$$/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

;;

esac

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

;;

lynxos*)

# FIXME: insert proper C++ library support

sysv5uw7* | unixware7*)

_LT_AC_TAGVAR(ld_shlibs, $1)=no

no_undefined_flag='${wl}-z ${wl}text'

;;

if test "$GCC" = yes; then

m88k*)

archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

# FIXME: insert proper C++ library support

else

_LT_AC_TAGVAR(ld_shlibs, $1)=no

archive_cmds='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

;;

mvs*)

runpath_var='LD_RUN_PATH'

case $cc_basename in

hardcode_shlibpath_var=no

cxx)

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

# FIXME: insert proper C++ library support

ld_shlibs=no

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

esac

;;

netbsd*)

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'

wlarc=

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

# Workaround some broken pre-1.5 toolchains

AC_MSG_RESULT([$ld_shlibs])

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'

test "$ld_shlibs" = no && can_build_shared=no

;;

osf3*)

case $cc_basename in

KCC)

# Kuck and Associates, Inc. (KAI) C++ Compiler

# KCC will only create a shared library if the output file

# ends with ".so" (or ".sl" for HP-UX), so rename the library

# to its proper name (with version) after linking.

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

# Archives containing C++ object files must be created using

# "CC -Bstatic", where "CC" is the KAI C++ compiler.

_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'

;;

RCC)

# Rational C++ 2.4.1

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

cxx)

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

# Commands to make compiler produce verbose output that lists

# what "hidden" libraries, object files and flags are used when

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/$^.*ld.*$$ .*ld.*$$/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

;;

if test "$GXX" = yes && test "$with_gnu_ld" = no; then

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

# Commands to make compiler produce verbose output that lists

# Check hardcoding attributes.

# what "hidden" libraries, object files and flags are used when

AC_MSG_CHECKING([how to hardcode library paths into programs])

# linking a shared library.

hardcode_action=

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

if test -n "$hardcode_libdir_flag_spec" || \

test -n "$runpath_var"; then

# We can hardcode non-existant directories.

if test "$hardcode_direct" != no &&

# If the only mechanism to avoid hardcoding is shlibpath_var, we

# have to relink, otherwise we might link with an installed library

# when we should be linking with a yet-to-be-installed one

## test "$hardcode_shlibpath_var" != no &&

test "$hardcode_minus_L" != no; then

# Linking always hardcodes the temporary library directory.

hardcode_action=relink

else

# FIXME: insert proper C++ library support

# We can link without hardcoding, and we can hardcode nonexisting dirs.

_LT_AC_TAGVAR(ld_shlibs, $1)=no

hardcode_action=immediate

;;

else

esac

# We cannot hardcode anything, or else we can only hardcode existing

;;

# directories.

osf4* | osf5*)

hardcode_action=unsupported

case $cc_basename in

KCC)

AC_MSG_RESULT([$hardcode_action])

# Kuck and Associates, Inc. (KAI) C++ Compiler

# KCC will only create a shared library if the output file

striplib=

# ends with ".so" (or ".sl" for HP-UX), so rename the library

old_striplib=

# to its proper name (with version) after linking.

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

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

reload_cmds='$LD$reload_flag -o $output$reload_objs'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

test -z "$deplibs_check_method" && deplibs_check_method=unknown

# Archives containing C++ object files must be created using

# PORTME Fill in your ld.so characteristics

# the KAI C++ compiler.

AC_MSG_CHECKING([dynamic linker characteristics])

_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs'

library_names_spec=

;;

libname_spec='lib$name'

RCC)

soname_spec=

# Rational C++ 2.4.1

postinstall_cmds=

# FIXME: insert proper C++ library support

postuninstall_cmds=

_LT_AC_TAGVAR(ld_shlibs, $1)=no

finish_cmds=

;;

finish_eval=

cxx)

shlibpath_var=

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

shlibpath_overrides_runpath=unknown

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'

version_type=none

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~

dynamic_linker="$host_os ld.so"

echo "-hidden">> $lib.exp~

sys_lib_dlsearch_path_spec="/lib /usr/lib"

$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp `test -n "$verstring" && echo -set_version $verstring` -update_registry $objdir/so_locations -o $lib~

sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

$rm $lib.exp'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

case $host_os in

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

aix3*)

version_type=linux

library_names_spec='${libname}${release}.so$versuffix $libname.a'

shlibpath_var=LIBPATH

# Commands to make compiler produce verbose output that lists

# AIX has no versioning support, so we append a major version to the name.

# what "hidden" libraries, object files and flags are used when

soname_spec='${libname}${release}.so$major'

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

;;

if test "$GXX" = yes && test "$with_gnu_ld" = no; then

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

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

aix4* | aix5*)

version_type=linux

need_lib_prefix=no

need_version=no

hardcode_into_libs=yes

if test "$host_cpu" = ia64; then

# AIX 5 supports IA64

library_names_spec='${libname}${release}.so$major ${libname}${release}.so$versuffix $libname.so'

shlibpath_var=LD_LIBRARY_PATH

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

# FIXME: insert proper C++ library support

can_build_shared=no

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

esac

# AIX (on Power*) has no versioning support, so currently we can

# not hardcode correct 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}.so$versuffix ${libname}${release}.so$major $libname.so'

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}.so$major'

shlibpath_var=LIBPATH

hardcode_into_libs=yes

;;

psos*)

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

sco*)

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

case $cc_basename in

CC)

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

esac

;;

sunos4*)

case $cc_basename in

CC)

# Sun C++ 4.x

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

lcc)

# Lucid

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

esac

;;

solaris*)

case $cc_basename in

CC)

# Sun C++ 4.2, 5.x and Centerline C++

_LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

$CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

case $host_os in

solaris2.[0-5] | solaris2.[0-5].*) ;;

# The C++ compiler is used as linker so we must use $wl

# flag to pass the commands to the underlying system

# linker.

# Supported since Solaris 2.6 (maybe 2.5.1?)

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'

;;

esac

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

# Commands to make compiler produce verbose output that lists

# what "hidden" libraries, object files and flags are used when

# linking a shared library.

# There doesn't appear to be a way to prevent this compiler from

# explicitly linking system object files so we need to strip them

# from the output so that they don't get included in the library

# dependencies.

output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep "\-[[LR]]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'

# Archives containing C++ object files must be created using

# "CC -xar", where "CC" is the Sun C++ compiler. This is

# necessary to make sure instantiated templates are included

# in the archive.

_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'

;;

gcx)

# Green Hills C++ Compiler

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

# The C++ compiler must be used to create the archive.

amigaos*)

_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'

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'

;;

# GNU C++ compiler with Solaris linker

if test "$GXX" = yes && test "$with_gnu_ld" = no; then

_LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'

if $CC --version | grep -v '^2\.7' > /dev/null; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

# Commands to make compiler produce verbose output that lists

beos*)

# what "hidden" libraries, object files and flags are used when

library_names_spec='${libname}.so'

# linking a shared library.

dynamic_linker="$host_os ld.so"

output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""

shlibpath_var=LIBRARY_PATH

else

;;

# g++ 2.7 appears to require `-G' NOT `-shared' on this

# platform.

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'

# 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 -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\""

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'

bsdi4*)

version_type=linux

need_version=no

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

soname_spec='${libname}${release}.so$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"

export_dynamic_flag_spec=-rdynamic

# 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

;;

esac

cygwin* | mingw* | pw32*)

version_type=windows

need_version=no

need_lib_prefix=no

case $GCC,$host_os in

yes,cygwin*)

library_names_spec='$libname.dll.a'

soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'

postinstall_cmds='dlpath=`bash 2>&1 -c '\''. $dir/${file}i;echo \$dlname'\''`~

dldir=$destdir/`dirname \$dlpath`~

test -d \$dldir || mkdir -p \$dldir~

$install_prog .libs/$dlname \$dldir/$dlname'

postuninstall_cmds='dldll=`bash 2>&1 -c '\''. $file; echo \$dlname'\''`~

dlpath=$dir/\$dldll~

$rm \$dlpath'

;;

sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)

yes,mingw*)

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'

sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | sed -e "s/^libraries://" -e "s/;/ /g" -e "s,=/,/,g"`

;;

tandem*)

yes,pw32*)

case $cc_basename in

library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll'

NCC)

# NonStop-UX NCC 3.20

# FIXME: insert proper C++ library support

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

# FIXME: insert proper C++ library support

library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll $libname.lib'

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

esac

dynamic_linker='Win32 ld.exe'

# FIXME: first we should search . and the directory the executable is in

shlibpath_var=PATH

;;

vxworks*)

# FIXME: insert proper C++ library support

darwin* | rhapsody*)

_LT_AC_TAGVAR(ld_shlibs, $1)=no

dynamic_linker="$host_os dyld"

;;

version_type=darwin

need_lib_prefix=no

# FIXME: insert proper C++ library support

need_version=no

_LT_AC_TAGVAR(ld_shlibs, $1)=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

;;

esac

AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])

test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

_LT_AC_TAGVAR(GCC, $1)="$GXX"

freebsd1*)

_LT_AC_TAGVAR(LD, $1)="$LD"

dynamic_linker=no

;;

AC_LIBTOOL_POSTDEP_PREDEP($1)

AC_LIBTOOL_PROG_COMPILER_PIC($1)

AC_LIBTOOL_PROG_CC_C_O($1)

AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

AC_LIBTOOL_PROG_LD_SHLIBS($1)

AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

AC_LIBTOOL_SYS_LIB_STRIP

AC_LIBTOOL_DLOPEN_SELF($1)

AC_LIBTOOL_CONFIG($1)

AC_LANG_POP

CC=$lt_save_CC

LDCXX=$LD

LD=$lt_save_LD

GCC=$lt_save_GCC

with_gnu_ldcxx=$with_gnu_ld

with_gnu_ld=$lt_save_with_gnu_ld

lt_cv_path_LDCXX=$lt_cv_path_LD

lt_cv_path_LD=$lt_save_path_LD

lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld

lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld

])# AC_LIBTOOL_LANG_CXX_CONFIG

# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME])

freebsd*)

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

objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`

# Figure out "hidden" library dependencies from verbose

version_type=freebsd-$objformat

# compiler output when linking a shared library.

case $version_type in

# Parse the compiler output and extract the necessary

freebsd-elf*)

# objects, libraries and library flags.

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so'

AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[

need_version=no

dnl we can't use the lt_simple_compile_test_code here,

need_lib_prefix=no

dnl because it contains code intended for an executable,

;;

dnl not a library. It's possible we should let each

freebsd-*)

dnl tag define a new lt_????_link_test_code variable,

library_names_spec='${libname}${release}.so$versuffix $libname.so$versuffix'

dnl but it's only used here...

need_version=yes

ifelse([$1],[],[cat > conftest.$ac_ext <<EOF

;;

int a;

esac

void foo (void) { a = 0; }

shlibpath_var=LD_LIBRARY_PATH

EOF

case $host_os in

],[$1],[CXX],[cat > conftest.$ac_ext <<EOF

freebsd2*)

class Foo

shlibpath_overrides_runpath=yes

{

;;

public:

Foo (void) { a = 0; }

shlibpath_overrides_runpath=no

private:

hardcode_into_libs=yes

int a;

;;

};

esac

EOF

;;

],[$1],[F77],[cat > conftest.$ac_ext <<EOF

subroutine foo

implicit none

integer*4 a

a=0

return

end

EOF

],[$1],[GCJ],[cat > conftest.$ac_ext <<EOF

public class foo {

private int a;

public void bar (void) {

a = 0;

}

};

EOF

])

dnl Parse the compiler output and extract the necessary

dnl objects, libraries and library flags.

if AC_TRY_EVAL(ac_compile); then

# Parse the compiler output and extract the necessary

# objects, libraries and library flags.

# Sentinel used to keep track of whether or not we are before

gnu*)

# the conftest object file.

version_type=linux

pre_test_object_deps_done=no

need_lib_prefix=no

need_version=no

# The `*' in the case matches for architectures that use `case' in

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so${major} ${libname}.so'

# $output_verbose_cmd can trigger glob expansion during the loop

soname_spec='${libname}${release}.so$major'

# eval without this substitution.

shlibpath_var=LD_LIBRARY_PATH

output_verbose_link_cmd="`$echo \"X$output_verbose_link_cmd\" | $Xsed -e \"$no_glob_subst\"`"

hardcode_into_libs=yes

;;

for p in `eval $output_verbose_link_cmd`; do

case $p in

-L* | -R* | -l*)

# Some compilers place space between "-{L,R}" and the path.

# Remove the space.

if test $p = "-L" \

|| test $p = "-R"; then

prev=$p

continue

else

prev=

if test "$pre_test_object_deps_done" = no; then

hpux9* | hpux10* | hpux11*)

case $p in

# Give a soname corresponding to the major version so that dld.sl refuses to

-L* | -R*)

# link against other versions.

# Internal compiler library paths should come after those

dynamic_linker="$host_os dld.sl"

# provided the user. The postdeps already come after the

version_type=sunos

# user supplied libs so there is no need to process them.

need_lib_prefix=no

if test -z "$_LT_AC_TAGVAR(compiler_lib_search_path, $1)"; then

need_version=no

_LT_AC_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"

shlibpath_var=SHLIB_PATH

else

shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

_LT_AC_TAGVAR(compiler_lib_search_path, $1)="${_LT_AC_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"

library_names_spec='${libname}${release}.sl$versuffix ${libname}${release}.sl$major $libname.sl'

soname_spec='${libname}${release}.sl$major'

# HP-UX runs *really* slowly unless shared libraries are mode 555.

postinstall_cmds='chmod 555 $lib'

;;

irix5* | irix6* | nonstopux*)

case $host_os in

nonstopux*) version_type=nonstopux ;;

*) version_type=irix ;;

esac

need_lib_prefix=no

need_version=no

soname_spec='${libname}${release}.so$major'

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so $libname.so'

case $host_os in

irix5* | nonstopux*)

libsuff= shlibsuff=

;;

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

;;

# The "-l" case would never come before the object being

# linked, so don't bother handling this case.

esac

else

shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

if test -z "$_LT_AC_TAGVAR(postdeps, $1)"; then

shlibpath_overrides_runpath=no

_LT_AC_TAGVAR(postdeps, $1)="${prev}${p}"

sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

else

sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

_LT_AC_TAGVAR(postdeps, $1)="${_LT_AC_TAGVAR(postdeps, $1)} ${prev}${p}"

;;

*.$objext)

# No shared lib support for Linux oldld, aout, or coff.

# This assumes that the test object file only shows up

linux-gnuoldld* | linux-gnuaout* | linux-gnucoff*)

# once in the compiler output.

dynamic_linker=no

if test "$p" = "conftest.$objext"; then

;;

pre_test_object_deps_done=yes

continue

if test "$pre_test_object_deps_done" = no; then

# This must be Linux ELF.

if test -z "$_LT_AC_TAGVAR(predep_objects, $1)"; then

linux-gnu*)

_LT_AC_TAGVAR(predep_objects, $1)="$p"

version_type=linux

else

need_lib_prefix=no

_LT_AC_TAGVAR(predep_objects, $1)="$_LT_AC_TAGVAR(predep_objects, $1) $p"

need_version=no

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

soname_spec='${libname}${release}.so$major'

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

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

# Find out which ABI we are using (multilib Linux x86_64 hack).

libsuff=

case "$host_cpu" in

x86_64*|s390x*)

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

if AC_TRY_EVAL(ac_compile); then

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

*64-bit*)

libsuff=64

;;

esac

rm -rf conftest*

;;

esac

sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff}"

sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/local/lib${libsuff}"

;;

netbsd*)

version_type=sunos

need_lib_prefix=no

need_version=no

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'

finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

dynamic_linker='NetBSD (a.out) ld.so'

else

if test -z "$_LT_AC_TAGVAR(postdep_objects, $1)"; then

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so ${libname}.so'

_LT_AC_TAGVAR(postdep_objects, $1)="$p"

soname_spec='${libname}${release}.so$major'

else

dynamic_linker='NetBSD ld.elf_so'

_LT_AC_TAGVAR(postdep_objects, $1)="$_LT_AC_TAGVAR(postdep_objects, $1) $p"

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

hardcode_into_libs=yes

;;

*) ;; # Ignore the rest.

newsos6)

version_type=linux

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

;;

openbsd*)

version_type=sunos

need_lib_prefix=no

need_version=no

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

;;

shlibpath_overrides_runpath=yes

;;

esac

done

# Clean up.

rm -f a.out a.exe

else

echo "libtool.m4: error: problem compiling $1 test program"

shlibpath_overrides_runpath=yes

library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'

finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

shlibpath_var=LD_LIBRARY_PATH

;;

$rm -f confest.$objext

os2*)

libname_spec='$name'

need_lib_prefix=no

library_names_spec='$libname.dll $libname.a'

dynamic_linker='OS/2 ld.exe'

shlibpath_var=LIBPATH

;;

case " $_LT_AC_TAGVAR(postdeps, $1) " in

osf3* | osf4* | osf5*)

*" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;

version_type=osf

esac

need_version=no

])# AC_LIBTOOL_POSTDEP_PREDEP

soname_spec='${libname}${release}.so$major'

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

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"

hardcode_into_libs=yes

;;

# AC_LIBTOOL_LANG_F77_CONFIG

sco3.2v5*)

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

version_type=osf

# Ensure that the configuration vars for the C compiler are

soname_spec='${libname}${release}.so$major'

# suitably defined. Those variables are subsequently used by

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

shlibpath_var=LD_LIBRARY_PATH

AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG], [_LT_AC_LANG_F77_CONFIG(F77)])

;;

AC_DEFUN([_LT_AC_LANG_F77_CONFIG],

[AC_REQUIRE([AC_PROG_F77])

solaris*)

AC_LANG_PUSH(Fortran 77)

version_type=linux

need_lib_prefix=no

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

need_version=no

_LT_AC_TAGVAR(allow_undefined_flag, $1)=

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

_LT_AC_TAGVAR(always_export_symbols, $1)=no

soname_spec='${libname}${release}.so$major'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)=

shlibpath_var=LD_LIBRARY_PATH

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

shlibpath_overrides_runpath=yes

_LT_AC_TAGVAR(hardcode_direct, $1)=no

hardcode_into_libs=yes

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

# ldd complains unless libraries are executable

_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

postinstall_cmds='chmod +x $lib'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

;;

_LT_AC_TAGVAR(hardcode_minus_L, $1)=no

_LT_AC_TAGVAR(hardcode_automatic, $1)=no

sunos4*)

_LT_AC_TAGVAR(module_cmds, $1)=

version_type=sunos

_LT_AC_TAGVAR(module_expsym_cmds, $1)=

library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'

_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown

finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

shlibpath_var=LD_LIBRARY_PATH

_LT_AC_TAGVAR(no_undefined_flag, $1)=

shlibpath_overrides_runpath=yes

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

if test "$with_gnu_ld" = yes; then

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no

need_lib_prefix=no

# Source file extension for f77 test sources.

need_version=yes

ac_ext=f

;;

# Object file extension for compiled f77 test sources.

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

objext=o

version_type=linux

_LT_AC_TAGVAR(objext, $1)=$objext

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

soname_spec='${libname}${release}.so$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)

need_lib_prefix=no

;;

motorola)

need_lib_prefix=no

need_version=no

shlibpath_overrides_runpath=no

sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

;;

esac

;;

# Code to be used in simple compile tests

uts4*)

lt_simple_compile_test_code=" subroutine t\n return\n end\n"

version_type=linux

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

soname_spec='${libname}${release}.so$major'

shlibpath_var=LD_LIBRARY_PATH

;;

# Code to be used in simple link tests

dgux*)

lt_simple_link_test_code=" program t\n end\n"

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

;;

# ltmain only uses $CC for tagged configurations so make sure $CC is set.

sysv4*MP*)

_LT_AC_SYS_COMPILER

if test -d /usr/nec ;then

version_type=linux

library_names_spec='$libname.so.$versuffix $libname.so.$major $libname.so'

soname_spec='$libname.so.$major'

shlibpath_var=LD_LIBRARY_PATH

;;

# Allow CC to be a program name with arguments.

lt_save_CC="$CC"

dynamic_linker=no

CC=${F77-"f77"}

;;

compiler=$CC

esac

_LT_AC_TAGVAR(compiler, $1)=$CC

AC_MSG_RESULT([$dynamic_linker])

cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`

test "$dynamic_linker" = no && can_build_shared=no

# Report the final consequences.

AC_MSG_CHECKING([if libtool supports shared libraries])

AC_MSG_RESULT([$can_build_shared])

Line 4704

Line 3214

postinstall_cmds='$RANLIB $lib'

;;

aix4*)

if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

test "$enable_shared" = yes && enable_static=no

;;

esac

AC_MSG_RESULT([$enable_shared])

Line 4715

Line 3228

test "$enable_shared" = yes || enable_static=yes

AC_MSG_RESULT([$enable_static])

test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

if test "$hardcode_action" = relink; then

# Fast installation is not supported

_LT_AC_TAGVAR(GCC, $1)="$G77"

enable_fast_install=no

_LT_AC_TAGVAR(LD, $1)="$LD"

elif test "$shlibpath_overrides_runpath" = yes ||

test "$enable_shared" = no; then

AC_LIBTOOL_PROG_COMPILER_PIC($1)

# Fast installation is not necessary

AC_LIBTOOL_PROG_CC_C_O($1)

enable_fast_install=needless

AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

AC_LIBTOOL_PROG_LD_SHLIBS($1)

AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

AC_LIBTOOL_SYS_LIB_STRIP

AC_LIBTOOL_CONFIG($1)

AC_LANG_POP

CC="$lt_save_CC"

])# AC_LIBTOOL_LANG_F77_CONFIG

# AC_LIBTOOL_LANG_GCJ_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_GCJ_CONFIG], [_LT_AC_LANG_GCJ_CONFIG(GCJ)])

AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG],

[AC_LANG_SAVE

# Source file extension for Java test sources.

ac_ext=java

# Object file extension for compiled Java test sources.

objext=o

_LT_AC_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests

lt_simple_compile_test_code="class foo {}\n"

# Code to be used in simple link tests

lt_simple_link_test_code='public class conftest { public static void main(String[] argv) {}; }\n'

# ltmain only uses $CC for tagged configurations so make sure $CC is set.

_LT_AC_SYS_COMPILER

# Allow CC to be a program name with arguments.

lt_save_CC="$CC"

CC=${GCJ-"gcj"}

compiler=$CC

_LT_AC_TAGVAR(compiler, $1)=$CC

# GCJ did not exist at the time GCC didn't implicitly link libc in.

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)

AC_LIBTOOL_PROG_COMPILER_PIC($1)

AC_LIBTOOL_PROG_CC_C_O($1)

AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

AC_LIBTOOL_PROG_LD_SHLIBS($1)

AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

AC_LIBTOOL_SYS_LIB_STRIP

AC_LIBTOOL_DLOPEN_SELF($1)

AC_LIBTOOL_CONFIG($1)

AC_LANG_RESTORE

CC="$lt_save_CC"

])# AC_LIBTOOL_LANG_GCJ_CONFIG

# AC_LIBTOOL_LANG_RC_CONFIG

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

# Ensure that the configuration vars for the Windows resource 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_RC_CONFIG], [_LT_AC_LANG_RC_CONFIG(RC)])

AC_DEFUN([_LT_AC_LANG_RC_CONFIG],

[AC_LANG_SAVE

# Source file extension for RC test sources.

ac_ext=rc

# Object file extension for compiled RC test sources.

objext=o

_LT_AC_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests

lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'

# Code to be used in simple link tests

lt_simple_link_test_code="$lt_simple_compile_test_code"

# ltmain only uses $CC for tagged configurations so make sure $CC is set.

_LT_AC_SYS_COMPILER

# Allow CC to be a program name with arguments.

variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

lt_save_CC="$CC"

if test "$GCC" = yes; then

CC=${RC-"windres"}

variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

compiler=$CC

_LT_AC_TAGVAR(compiler, $1)=$CC

_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

AC_LIBTOOL_CONFIG($1)

AC_LIBTOOL_DLOPEN_SELF

AC_LANG_RESTORE

if test "$enable_shared" = yes && test "$GCC" = yes; then

CC="$lt_save_CC"

case $archive_cmds in

])# AC_LIBTOOL_LANG_RC_CONFIG

*'~'*)

# FIXME: we may have to deal with multi-command sequences.

;;

'$CC '*)

# Test whether the compiler implicitly links with -lc since on some

# systems, -lgcc has to come before -lc. If gcc already passes -lc

# to ld, don't add -lc before -lgcc.

AC_MSG_CHECKING([whether -lc should be explicitly linked in])

AC_CACHE_VAL([lt_cv_archive_cmds_need_lc],

[$rm conftest*

echo 'static int dummy;' > conftest.$ac_ext

if AC_TRY_EVAL(ac_compile); then

soname=conftest

lib=conftest

libobjs=conftest.$ac_objext

deplibs=

wl=$lt_cv_prog_cc_wl

compiler_flags=-v

linker_flags=-v

verstring=

output_objdir=.

libname=conftest

save_allow_undefined_flag=$allow_undefined_flag

allow_undefined_flag=

if AC_TRY_EVAL(archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1)

then

lt_cv_archive_cmds_need_lc=no

else

lt_cv_archive_cmds_need_lc=yes

allow_undefined_flag=$save_allow_undefined_flag

else

cat conftest.err 1>&5

fi])

AC_MSG_RESULT([$lt_cv_archive_cmds_need_lc])

;;

esac

need_lc=${lt_cv_archive_cmds_need_lc-yes}

# AC_LIBTOOL_CONFIG([TAGNAME])

# The second clause should only fire when bootstrapping the

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

# If TAGNAME is not passed, then create an initial libtool script

# with a default configuration from the untagged config vars. Otherwise

# add code to config.status for appending the configuration named by

# TAGNAME from the matching tagged config vars.

AC_DEFUN([AC_LIBTOOL_CONFIG],

[# The else clause should only fire when bootstrapping the

# libtool distribution, otherwise you forgot to ship ltmain.sh

# with your package, and you will get complaints that there are

# no rules to generate ltmain.sh.

if test -f "$ltmain"; then

# See if we are running on zsh, and set the options which allow our commands through

# without removal of \ escapes.

else

if test -n "${ZSH_VERSION+set}" ; then

# If there is no Makefile yet, we rely on a make rule to execute

setopt NO_GLOB_SUBST

# `config.status --recheck' to rerun these tests and create the

# libtool script then.

test -f Makefile && make "$ltmain"

if test -f "$ltmain"; then

trap "$rm \"${ofile}T\"; exit 1" 1 2 15

$rm -f "${ofile}T"

echo creating $ofile

# Now quote all the things that may contain metacharacters while being

# careful not to overquote the AC_SUBSTed values. We take copies of the

# variables and quote the copies for generation of the libtool script.

for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \

for var in echo old_CC old_CFLAGS SED \

SED SHELL STRIP \

AR AR_FLAGS CC LD LN_S NM SHELL \

libname_spec library_names_spec soname_spec extract_expsyms_cmds \

reload_flag reload_cmds wl \

old_striplib striplib file_magic_cmd finish_cmds finish_eval \

pic_flag link_static_flag no_builtin_flag export_dynamic_flag_spec \

deplibs_check_method reload_flag reload_cmds need_locks \

thread_safe_flag_spec whole_archive_flag_spec libname_spec \

lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \

library_names_spec soname_spec \

lt_cv_sys_global_symbol_to_c_name_address \

RANLIB old_archive_cmds old_archive_from_new_cmds old_postinstall_cmds \

old_postuninstall_cmds archive_cmds archive_expsym_cmds postinstall_cmds \

postuninstall_cmds extract_expsyms_cmds old_archive_from_expsyms_cmds \

old_striplib striplib file_magic_cmd export_symbols_cmds \

deplibs_check_method allow_undefined_flag no_undefined_flag \

finish_cmds finish_eval global_symbol_pipe global_symbol_to_cdecl \

global_symbol_to_c_name_address \

hardcode_libdir_flag_spec hardcode_libdir_separator \

sys_lib_search_path_spec sys_lib_dlsearch_path_spec \

old_postinstall_cmds old_postuninstall_cmds \

compiler_c_o compiler_o_lo need_locks exclude_expsyms include_expsyms; do

_LT_AC_TAGVAR(compiler, $1) \

_LT_AC_TAGVAR(CC, $1) \

_LT_AC_TAGVAR(LD, $1) \

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1) \

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) \

_LT_AC_TAGVAR(lt_prog_compiler_static, $1) \

_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) \

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1) \

_LT_AC_TAGVAR(thread_safe_flag_spec, $1) \

_LT_AC_TAGVAR(whole_archive_flag_spec, $1) \

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1) \

_LT_AC_TAGVAR(old_archive_cmds, $1) \

_LT_AC_TAGVAR(old_archive_from_new_cmds, $1) \

_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) \

_LT_AC_TAGVAR(archive_cmds, $1) \

_LT_AC_TAGVAR(archive_expsym_cmds, $1) \

_LT_AC_TAGVAR(postinstall_cmds, $1) \

_LT_AC_TAGVAR(postuninstall_cmds, $1) \

_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) \

_LT_AC_TAGVAR(allow_undefined_flag, $1) \

_LT_AC_TAGVAR(no_undefined_flag, $1) \

_LT_AC_TAGVAR(export_symbols_cmds, $1) \

_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_automatic, $1) \

_LT_AC_TAGVAR(module_cmds, $1) \

_LT_AC_TAGVAR(module_expsym_cmds, $1) \

_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1) \

_LT_AC_TAGVAR(exclude_expsyms, $1) \

_LT_AC_TAGVAR(include_expsyms, $1); do

case $var in

_LT_AC_TAGVAR(old_archive_cmds, $1) | \

reload_cmds | old_archive_cmds | old_archive_from_new_cmds | \

_LT_AC_TAGVAR(old_archive_from_new_cmds, $1) | \

_LT_AC_TAGVAR(archive_cmds, $1) | \

_LT_AC_TAGVAR(archive_expsym_cmds, $1) | \

_LT_AC_TAGVAR(module_cmds, $1) | \

_LT_AC_TAGVAR(module_expsym_cmds, $1) | \

_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) | \

_LT_AC_TAGVAR(export_symbols_cmds, $1) | \

extract_expsyms_cmds | reload_cmds | finish_cmds | \

postinstall_cmds | postuninstall_cmds | \

old_postinstall_cmds | old_postuninstall_cmds | \

sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

export_symbols_cmds | archive_cmds | archive_expsym_cmds | \

extract_expsyms_cmds | old_archive_from_expsyms_cmds | \

postinstall_cmds | postuninstall_cmds | \

finish_cmds | sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)

# Double-quote double-evaled strings.

eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""

;;

Line 4913

Line 3342

esac

done

case $lt_echo in

cat <<__EOF__ > "${ofile}T"

*'\[$]0 --fallback-echo"')

#! $SHELL

lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\[$]0 --fallback-echo"[$]/[$]0 --fallback-echo"/'`

;;

esac

ifelse([$1], [],

[cfgfile="${ofile}T"

trap "$rm \"$cfgfile\"; exit 1" 1 2 15

$rm -f "$cfgfile"

AC_MSG_NOTICE([creating $ofile])],

[cfgfile="$ofile"])

cat <<__EOF__ >> "$cfgfile"

ifelse([$1], [],

[#! $SHELL

# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services.

# `$echo "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.

# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)

# NOTE: Changes made to this file will be lost: look at ltmain.sh.

# Free Software Foundation, Inc.

# This file is part of GNU Libtool:

# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

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

Line 4959

Line 3371

# configuration script generated by Autoconf, you may include it under

# the same distribution terms that you use for the rest of that program.

# A sed program that does not truncate output.

# A sed that does not truncate output.

SED=$lt_SED

# Sed that helps us avoid accidentally triggering echo(1) options like -n.

Xsed="$SED -e s/^X//"

Xsed="${SED} -e s/^X//"

# 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

# The names of the tagged configurations supported by this script.

# ### BEGIN LIBTOOL CONFIG

available_tags=

# ### BEGIN LIBTOOL CONFIG],

[# ### BEGIN LIBTOOL TAG CONFIG: $tagname])

# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

Line 4987

Line 3395

build_old_libs=$enable_static

# Whether or not to add -lc for building shared libraries.

build_libtool_need_lc=$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)

build_libtool_need_lc=$need_lc

# Whether or not to disallow shared libs when runtime libs are static

allow_libtool_libs_with_static_runtimes=$_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)

# Whether or not to optimize for fast installation.

fast_install=$enable_fast_install

Line 5006

Line 3411

AR=$lt_AR

AR_FLAGS=$lt_AR_FLAGS

# A C compiler.

# The default C compiler.

LTCC=$lt_LTCC

CC=$lt_CC

# A language-specific compiler.

CC=$lt_[]_LT_AC_TAGVAR(compiler, $1)

# Is the compiler the GNU C compiler?

with_gcc=$_LT_AC_TAGVAR(GCC, $1)

with_gcc=$GCC

# An ERE matcher.

EGREP=$lt_EGREP

# The linker used to build libraries.

LD=$lt_[]_LT_AC_TAGVAR(LD, $1)

LD=$lt_LD

# Whether we need hard or soft links.

LN_S=$lt_LN_S

Line 5028

Line 3427

NM=$lt_NM

# A symbol stripping program

STRIP=$lt_STRIP

STRIP=$STRIP

# Used to examine libraries when file_magic_cmd begins "file"

MAGIC_CMD=$MAGIC_CMD

Line 5050

Line 3449

reload_cmds=$lt_reload_cmds

# How to pass a linker flag through the compiler.

wl=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)

wl=$lt_wl

# Object file suffix (normally "o").

objext="$ac_objext"

Line 5058

Line 3457

# Old archive suffix (normally "a").

libext="$libext"

# Shared library suffix (normally ".so").

shrext='$shrext'

# Executable file suffix (normally "").

exeext="$exeext"

# Additional compiler flags for building library objects.

pic_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)

pic_flag=$lt_pic_flag

pic_mode=$pic_mode

# What is the maximum length of a command?

max_cmd_len=$lt_cv_sys_max_cmd_len

# Does compiler simultaneously support -c and -o options?

compiler_c_o=$lt_[]_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)

compiler_c_o=$lt_compiler_c_o

# Can we write directly to a .lo ?

compiler_o_lo=$lt_compiler_o_lo

# Must we lock files when doing compilation ?

need_locks=$lt_need_locks

Line 5093

Line 3489

dlopen_self_static=$enable_dlopen_self_static

# Compiler flag to prevent dynamic linking.

link_static_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_static, $1)

link_static_flag=$lt_link_static_flag

# Compiler flag to turn off builtin functions.

no_builtin_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)

no_builtin_flag=$lt_no_builtin_flag

# Compiler flag to allow reflexive dlopens.

export_dynamic_flag_spec=$lt_[]_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)

export_dynamic_flag_spec=$lt_export_dynamic_flag_spec

# Compiler flag to generate shared objects directly from archives.

whole_archive_flag_spec=$lt_[]_LT_AC_TAGVAR(whole_archive_flag_spec, $1)

whole_archive_flag_spec=$lt_whole_archive_flag_spec

# Compiler flag to generate thread-safe objects.

thread_safe_flag_spec=$lt_[]_LT_AC_TAGVAR(thread_safe_flag_spec, $1)

# Library versioning type.

version_type=$version_type

# Format of library name prefix.

libname_spec=$lt_libname_spec

# List of archive names. First name is the real one, the rest are links.

# The last name is the one that the linker finds with -lNAME.

library_names_spec=$lt_library_names_spec

# The coded name of the library, if different from the real name.

soname_spec=$lt_soname_spec

# Commands used to build and install an old-style archive.

RANLIB=$lt_RANLIB

old_archive_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_cmds, $1)

old_postinstall_cmds=$lt_old_postinstall_cmds

old_postuninstall_cmds=$lt_old_postuninstall_cmds

# Create an old-style archive from a shared archive.

old_archive_from_new_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_new_cmds, $1)

# Create a temporary old-style archive to link instead of a shared archive.

old_archive_from_expsyms_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)

# Commands used to build and install a shared archive.

archive_cmds=$lt_[]_LT_AC_TAGVAR(archive_cmds, $1)

archive_expsym_cmds=$lt_[]_LT_AC_TAGVAR(archive_expsym_cmds, $1)

postinstall_cmds=$lt_postinstall_cmds

postuninstall_cmds=$lt_postuninstall_cmds

# Commands used to build a loadable module (assumed same as above if empty)

module_cmds=$lt_[]_LT_AC_TAGVAR(module_cmds, $1)

module_expsym_cmds=$lt_[]_LT_AC_TAGVAR(module_expsym_cmds, $1)

# Commands to strip libraries.

old_striplib=$lt_old_striplib

striplib=$lt_striplib

# Dependencies to place before the objects being linked to create a

# shared library.

predep_objects=$lt_[]_LT_AC_TAGVAR(predep_objects, $1)

# Dependencies to place after the objects being linked to create a

# shared library.

postdep_objects=$lt_[]_LT_AC_TAGVAR(postdep_objects, $1)

# Dependencies to place before the objects being linked to create a

# shared library.

predeps=$lt_[]_LT_AC_TAGVAR(predeps, $1)

# Dependencies to place after the objects being linked to create a

# shared library.

postdeps=$lt_[]_LT_AC_TAGVAR(postdeps, $1)

# The library search path used internally by the compiler when linking

# a shared library.

compiler_lib_search_path=$lt_[]_LT_AC_TAGVAR(compiler_lib_search_path, $1)

# Method to check whether dependent libraries are shared objects.

deplibs_check_method=$lt_deplibs_check_method

# Command to use when deplibs_check_method == file_magic.

file_magic_cmd=$lt_file_magic_cmd

# Flag that allows shared libraries with undefined symbols to be built.

allow_undefined_flag=$lt_[]_LT_AC_TAGVAR(allow_undefined_flag, $1)

# Flag that forces no undefined symbols.

no_undefined_flag=$lt_[]_LT_AC_TAGVAR(no_undefined_flag, $1)

# Commands used to finish a libtool library installation in a directory.

finish_cmds=$lt_finish_cmds

# Same as above, but a single script fragment to be evaled but not shown.

finish_eval=$lt_finish_eval

# Take the output of nm and produce a listing of raw symbols and C names.

global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

# Transform the output of nm in a proper C declaration

global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

# Transform the output of nm in a C name address pair

global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

# This is the shared library runtime path variable.

runpath_var=$runpath_var

# This is the shared library path variable.

shlibpath_var=$shlibpath_var

# Is shlibpath searched before the hard-coded library search path?

shlibpath_overrides_runpath=$shlibpath_overrides_runpath

# How to hardcode a shared library path into an executable.

hardcode_action=$_LT_AC_TAGVAR(hardcode_action, $1)

# Whether we should hardcode library paths into libraries.

hardcode_into_libs=$hardcode_into_libs

# Flag to hardcode \$libdir into a binary during linking.

# This must work even if \$libdir does not exist.

hardcode_libdir_flag_spec=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)

# If ld is used when linking, flag to hardcode \$libdir into

# a binary during linking. This must work even if \$libdir does

# not exist.

hardcode_libdir_flag_spec_ld=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)

# Whether we need a single -rpath flag with a separated argument.

hardcode_libdir_separator=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_separator, $1)

# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the

# resulting binary.

hardcode_direct=$_LT_AC_TAGVAR(hardcode_direct, $1)

# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

# resulting binary.

hardcode_minus_L=$_LT_AC_TAGVAR(hardcode_minus_L, $1)

# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

# the resulting binary.

hardcode_shlibpath_var=$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)

# Set to yes if building a shared library automatically hardcodes DIR into the library

# and all subsequent libraries and executables linked against it.

hardcode_automatic=$_LT_AC_TAGVAR(hardcode_automatic, $1)

# Variables whose values should be saved in libtool wrapper scripts and

# restored at relink time.

variables_saved_for_relink="$variables_saved_for_relink"

# Whether libtool must link a program against all its dependency libraries.

link_all_deplibs=$_LT_AC_TAGVAR(link_all_deplibs, $1)

# Compile-time system search path for libraries

sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

# Run-time system search path for libraries

sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

# Fix the shell variable \$srcfile for the compiler.

fix_srcfile_path="$_LT_AC_TAGVAR(fix_srcfile_path, $1)"

# Set to yes if exported symbols are required.

always_export_symbols=$_LT_AC_TAGVAR(always_export_symbols, $1)

# The commands to list exported symbols.

export_symbols_cmds=$lt_[]_LT_AC_TAGVAR(export_symbols_cmds, $1)

# The commands to extract the exported symbol list from a shared archive.

extract_expsyms_cmds=$lt_extract_expsyms_cmds

# Symbols that should not be listed in the preloaded symbols.

exclude_expsyms=$lt_[]_LT_AC_TAGVAR(exclude_expsyms, $1)

# Symbols that must always be exported.

include_expsyms=$lt_[]_LT_AC_TAGVAR(include_expsyms, $1)

ifelse([$1],[],

[# ### END LIBTOOL CONFIG],

[# ### END LIBTOOL TAG CONFIG: $tagname])

__EOF__

ifelse([$1],[], [

case $host_os in

aix3*)

cat <<\EOF >> "$cfgfile"

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

# reason, if we set the COLLECT_NAMES environment variable, the problems

# vanish in a puff of smoke.

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

COLLECT_NAMES=

export COLLECT_NAMES

EOF

;;

esac

# We use sed instead of cat because bash on DJGPP gets confused if

# if finds mixed CR/LF and LF-only lines. Since sed operates in

# text mode, it properly converts lines to CR/LF. This bash problem

# is reportedly fixed, but why not run on old versions too?

sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)

mv -f "$cfgfile" "$ofile" || \

(rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")

chmod +x "$ofile"

])

else

# If there is no Makefile yet, we rely on a make rule to execute

# `config.status --recheck' to rerun these tests and create the

# libtool script then.

ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`

if test -f "$ltmain_in"; then

test -f Makefile && make "$ltmain"

])# AC_LIBTOOL_CONFIG

# AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME])

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

AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI],

[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=

if test "$GCC" = yes; then

_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'

AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],

lt_cv_prog_compiler_rtti_exceptions,

[-fno-rtti -fno-exceptions], [],

[_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])

])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI

# 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 from $compiler object])

AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],

[

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

symcode='[[BCDEGRST]]'

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

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

# Transform an extracted symbol line into a proper C declaration

# Compiler flag to generate thread-safe objects.

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

thread_safe_flag_spec=$lt_thread_safe_flag_spec

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

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

case $host_os in

aix*)

symcode='[[BCDT]]'

;;

cygwin* | mingw* | pw32*)

symcode='[[ABCDGISTW]]'

;;

hpux*) # Its linker distinguishes data from code symbols

if test "$host_cpu" = ia64; then

symcode='[[ABCDEGRST]]'

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

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

;;

irix* | nonstopux*)

symcode='[[BCDEGRST]]'

;;

osf*)

symcode='[[BCDEGQRST]]'

;;

solaris* | sysv5*)

symcode='[[BDRT]]'

;;

sysv4)

symcode='[[DFNSTU]]'

;;

esac

# Handle CRLF in mingw tool chain

opt_cr=

case $build_os in

mingw*)

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

;;

esac

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

case `$NM -V 2>&1` in

*GNU* | *'with BFD'*)

symcode='[[ABCDGIRSTW]]' ;;

esac

# Try without a prefix undercore, then with it.

for ac_symprfx in "" "_"; do

# Write the raw and C identifiers.

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

# 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

# Now try to grab the symbols.

nlist=conftest.nm

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

# Try sorting and uniquifying the output.

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

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

else

rm -f "$nlist"T

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

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

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

cat <<EOF > conftest.$ac_ext

#ifdef __cplusplus

extern "C" {

#endif

EOF

# Now generate the symbol file.

eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'

cat <<EOF >> conftest.$ac_ext

#if defined (__STDC__) && __STDC__

# define lt_ptr_t void *

#else

# define lt_ptr_t char *

# define const

#endif

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

const struct {

const char *name;

lt_ptr_t address;

}

lt_preloaded_symbols[[]] =

{

EOF

$SED "s/^$symcode$symcode* $.*$ $.*$$/ {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext

cat <<\EOF >> conftest.$ac_ext

{0, (lt_ptr_t) 0}

};

#ifdef __cplusplus

}

#endif

EOF

# Now try linking the two files.

mv conftest.$ac_objext conftstm.$ac_objext

lt_save_LIBS="$LIBS"

lt_save_CFLAGS="$CFLAGS"

LIBS="conftstm.$ac_objext"

CFLAGS="$CFLAGS$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"

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

pipe_works=yes

LIBS="$lt_save_LIBS"

CFLAGS="$lt_save_CFLAGS"

else

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

else

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

else

echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD

else

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

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

break

else

lt_cv_sys_global_symbol_pipe=

done

])

if test -z "$lt_cv_sys_global_symbol_pipe"; then

lt_cv_sys_global_symbol_to_cdecl=

if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then

AC_MSG_RESULT(failed)

else

AC_MSG_RESULT(ok)

]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

# AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME])

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

AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC],

[_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)=

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=

AC_MSG_CHECKING([for $compiler option to produce PIC])

ifelse([$1],[CXX],[

# C++ specific cases for pic, static, wl, etc.

if test "$GXX" = yes; then

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

case $host_os in

aix*)

# All AIX code is PIC.

if test "$host_cpu" = ia64; then

# AIX 5 now supports IA64 processor

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

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_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'

;;

# PIC is the default for these OSes.

;;

mingw* | os2* | pw32*)

# 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_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'

;;

darwin* | rhapsody*)

# PIC is the default on this platform

# Common symbols not allowed in MH_DYLIB files

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'

;;

*djgpp*)

# DJGPP does not support shared libraries at all

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

;;

sysv4*MP*)

if test -d /usr/nec; then

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic

;;

hpux*)

# PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

# not for PA HP-UX.

case "$host_cpu" in

hppa*64*|ia64*)

;;

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

;;

esac

;;

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

;;

esac

else

case $host_os in

aix4* | aix5*)

# All AIX code is PIC.

if test "$host_cpu" = ia64; then

# AIX 5 now supports IA64 processor

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

else

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'

;;

chorus*)

case $cc_basename in

cxch68)

# Green Hills C++ Compiler

# _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"

;;

esac

;;

dgux*)

case $cc_basename in

ec++)

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

;;

ghcx)

# Green Hills C++ Compiler

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

;;

esac

;;

freebsd* | kfreebsd*-gnu)

# FreeBSD uses GNU C++

;;

hpux9* | hpux10* | hpux11*)

case $cc_basename in

CC)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"

if test "$host_cpu" != ia64; then

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'

;;

aCC)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"

case "$host_cpu" in

hppa*64*|ia64*)

# +Z the default

;;

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'

;;

esac

;;

esac

;;

irix5* | irix6* | nonstopux*)

case $cc_basename in

CC)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

# CC pic flag -KPIC is the default.

;;

esac

;;

linux*)

case $cc_basename in

KCC)

# KAI C++ Compiler

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

;;

icpc)

# Intel C++

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

;;

cxx)

# Compaq C++

# Make sure the PIC flag is empty. It appears that all Alpha

# Linux and Compaq Tru64 Unix objects are PIC.

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

;;

esac

;;

lynxos*)

;;

m88k*)

;;

mvs*)

case $cc_basename in

cxx)

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'

;;

esac

;;

netbsd*)

;;

osf3* | osf4* | osf5*)

case $cc_basename in

KCC)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'

;;

RCC)

# Rational C++ 2.4.1

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

;;

cxx)

# Digital/Compaq C++

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

# Make sure the PIC flag is empty. It appears that all Alpha

# Linux and Compaq Tru64 Unix objects are PIC.

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

;;

esac

;;

psos*)

;;

sco*)

case $cc_basename in

CC)

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

;;

esac

;;

solaris*)

case $cc_basename in

CC)

# Sun C++ 4.2, 5.x and Centerline C++

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '

;;

gcx)

# Green Hills C++ Compiler

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'

;;

esac

;;

sunos4*)

case $cc_basename in

CC)

# Sun C++ 4.x

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

lcc)

# Lucid

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

;;

esac

;;

tandem*)

case $cc_basename in

NCC)

# NonStop-UX NCC 3.20

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

;;

esac

;;

unixware*)

;;

vxworks*)

;;

_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

;;

esac

[

if test "$GCC" = yes; then

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

case $host_os in

# Library versioning type.

aix*)

version_type=$version_type

# All AIX code is PIC.

if test "$host_cpu" = ia64; then

# AIX 5 now supports IA64 processor

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

amigaos*)

# Format of library name prefix.

# FIXME: we need at least 68020 code to build shared libraries, but

libname_spec=$lt_libname_spec

# adding the `-m68020' flag to GCC prevents building anything better,

# like `-m68040'.

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'

;;

# List of archive names. First name is the real one, the rest are links.

# PIC is the default for these OSes.

# The last name is the one that the linker finds with -lNAME.

;;

library_names_spec=$lt_library_names_spec

mingw* | pw32* | os2*)

# The coded name of the library, if different from the real name.

# This hack is so that the source file can tell whether it is being

soname_spec=$lt_soname_spec

# built for inclusion in a dll (and should export symbols for example).

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'

;;

darwin* | rhapsody*)

# Commands used to build and install an old-style archive.

# PIC is the default on this platform

RANLIB=$lt_RANLIB

# Common symbols not allowed in MH_DYLIB files

old_archive_cmds=$lt_old_archive_cmds

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'

old_postinstall_cmds=$lt_old_postinstall_cmds

;;

old_postuninstall_cmds=$lt_old_postuninstall_cmds

msdosdjgpp*)

# Create an old-style archive from a shared archive.

# Just because we use GCC doesn't mean we suddenly get shared libraries

old_archive_from_new_cmds=$lt_old_archive_from_new_cmds

# on systems that don't support them.

_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

enable_shared=no

;;

sysv4*MP*)

# Create a temporary old-style archive to link instead of a shared archive.

if test -d /usr/nec; then

old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic

;;

hpux*)

# Commands used to build and install a shared archive.

# PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

archive_cmds=$lt_archive_cmds

# not for PA HP-UX.

archive_expsym_cmds=$lt_archive_expsym_cmds

case "$host_cpu" in

postinstall_cmds=$lt_postinstall_cmds

hppa*64*|ia64*)

postuninstall_cmds=$lt_postuninstall_cmds

# +Z the default

;;

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

;;

esac

;;

# Commands to strip libraries.

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'

old_striplib=$lt_old_striplib

;;

striplib=$lt_striplib

esac

else

# PORTME Check for flag to pass linker flags through the system compiler.

case $host_os in

aix*)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

if test "$host_cpu" = ia64; then

# AIX 5 now supports IA64 processor

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

else

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'

;;

mingw* | pw32* | os2*)

# Method to check whether dependent libraries are shared objects.

# This hack is so that the source file can tell whether it is being

deplibs_check_method=$lt_deplibs_check_method

# built for inclusion in a dll (and should export symbols for example).

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'

;;

hpux9* | hpux10* | hpux11*)

# Command to use when deplibs_check_method == file_magic.

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

file_magic_cmd=$lt_file_magic_cmd

# PIC is the default for IA64 HP-UX and 64-bit HP-UX, but

# not for PA HP-UX.

case "$host_cpu" in

hppa*64*|ia64*)

# +Z the default

;;

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'

;;

esac

# Is there a better lt_prog_compiler_static that works with the bundled CC?

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'

;;

irix5* | irix6* | nonstopux*)

# Flag that allows shared libraries with undefined symbols to be built.

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

allow_undefined_flag=$lt_allow_undefined_flag

# PIC (with -KPIC) is the default.

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

;;

newsos6)

# Flag that forces no undefined symbols.

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

no_undefined_flag=$lt_no_undefined_flag

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

linux*)

# Commands used to finish a libtool library installation in a directory.

case $CC in

finish_cmds=$lt_finish_cmds

icc* | ecc*)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'

;;

ccc*)

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

# All Alpha code is PIC.

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

;;

esac

;;

osf3* | osf4* | osf5*)

# Same as above, but a single script fragment to be evaled but not shown.

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

finish_eval=$lt_finish_eval

# All OSF/1 code is PIC.

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'

;;

sco3.2v5*)

# Take the output of nm and produce a listing of raw symbols and C names.

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kpic'

global_symbol_pipe=$lt_global_symbol_pipe

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-dn'

;;

solaris*)

# Transform the output of nm in a proper C declaration

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

global_symbol_to_cdecl=$lt_global_symbol_to_cdecl

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

sunos4*)

# Transform the output of nm in a C name address pair

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '

global_symbol_to_c_name_address=$lt_global_symbol_to_c_name_address

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

# This is the shared library runtime path variable.

_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'

runpath_var=$runpath_var

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

sysv4*MP*)

# This is the shared library path variable.

if test -d /usr/nec ;then

shlibpath_var=$shlibpath_var

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

uts4*)

# Is shlibpath searched before the hard-coded library search path?

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'

shlibpath_overrides_runpath=$shlibpath_overrides_runpath

_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'

;;

# How to hardcode a shared library path into an executable.

_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no

hardcode_action=$hardcode_action

# Whether we should hardcode library paths into libraries.

hardcode_into_libs=$hardcode_into_libs

# Flag to hardcode \$libdir into a binary during linking.

# This must work even if \$libdir does not exist.

hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec

# Whether we need a single -rpath flag with a separated argument.

hardcode_libdir_separator=$lt_hardcode_libdir_separator

# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the

# resulting binary.

hardcode_direct=$hardcode_direct

# Set to yes if using the -LDIR flag during linking hardcodes DIR into the

# resulting binary.

hardcode_minus_L=$hardcode_minus_L

# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into

# the resulting binary.

hardcode_shlibpath_var=$hardcode_shlibpath_var

# Variables whose values should be saved in libtool wrapper scripts and

# restored at relink time.

variables_saved_for_relink="$variables_saved_for_relink"

# Whether libtool must link a program against all its dependency libraries.

link_all_deplibs=$link_all_deplibs

# Compile-time system search path for libraries

sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

# Run-time system search path for libraries

sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

# Fix the shell variable \$srcfile for the compiler.

fix_srcfile_path="$fix_srcfile_path"

# Set to yes if exported symbols are required.

always_export_symbols=$always_export_symbols

# The commands to list exported symbols.

export_symbols_cmds=$lt_export_symbols_cmds

# The commands to extract the exported symbol list from a shared archive.

extract_expsyms_cmds=$lt_extract_expsyms_cmds

# Symbols that should not be listed in the preloaded symbols.

exclude_expsyms=$lt_exclude_expsyms

# Symbols that must always be exported.

include_expsyms=$lt_include_expsyms

# ### END LIBTOOL CONFIG

__EOF__

case $host_os in

aix3*)

cat <<\EOF >> "${ofile}T"

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

# reason, if we set the COLLECT_NAMES environment variable, the problems

# vanish in a puff of smoke.

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

COLLECT_NAMES=

export COLLECT_NAMES

EOF

;;

esac

])

AC_MSG_RESULT([$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)])

case $host_os in

cygwin* | mingw* | pw32* | os2*)

cat <<'EOF' >> "${ofile}T"

# This is a source program that is used to create dlls on Windows

# Don't remove nor modify the starting and closing comments

# /* ltdll.c starts here */

# #define WIN32_LEAN_AND_MEAN

# #include <windows.h>

# #undef WIN32_LEAN_AND_MEAN

# #include <stdio.h>

# #ifndef __CYGWIN__

# # ifdef __CYGWIN32__

# # define __CYGWIN__ __CYGWIN32__

# # endif

# #endif

# #ifdef __cplusplus

# extern "C" {

# #endif

# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);

# #ifdef __cplusplus

# }

# #endif

# #ifdef __CYGWIN__

# #include <cygwin/cygwin_dll.h>

# DECLARE_CYGWIN_DLL( DllMain );

# #endif

# HINSTANCE __hDllInstance_base;

# BOOL APIENTRY

# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)

# {

# __hDllInstance_base = hInst;

# return TRUE;

# }

# /* ltdll.c ends here */

# This is a source program that is used to create import libraries

# on Windows for dlls which lack them. Don't remove nor modify the

# starting and closing comments

# /* impgen.c starts here */

# This file is part of GNU libtool.

# 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 of the License, 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.

# */

# #include <stdio.h> /* for printf() */

# #include <unistd.h> /* for open(), lseek(), read() */

# #include <fcntl.h> /* for O_RDONLY, O_BINARY */

# #include <string.h> /* for strdup() */

# /* O_BINARY isn't required (or even defined sometimes) under Unix */

# #ifndef O_BINARY

# #define O_BINARY 0

# #endif

# static unsigned int

# pe_get16 (fd, offset)

# int fd;

# int offset;

# {

# unsigned char b[2];

# lseek (fd, offset, SEEK_SET);

# read (fd, b, 2);

# return b[0] + (b[1]<<8);

# }

# static unsigned int

# pe_get32 (fd, offset)

# int fd;

# int offset;

# {

# unsigned char b[4];

# lseek (fd, offset, SEEK_SET);

# read (fd, b, 4);

# return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);

# }

# static unsigned int

# pe_as32 (ptr)

# void *ptr;

# {

# unsigned char *b = ptr;

# return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);

# }

# int

# main (argc, argv)

# int argc;

# char *argv[];

# {

# int dll;

# unsigned long pe_header_offset, opthdr_ofs, num_entries, i;

# unsigned long export_rva, export_size, nsections, secptr, expptr;

# unsigned long name_rvas, nexp;

# unsigned char *expdata, *erva;

# char *filename, *dll_name;

# filename = argv[1];

# dll = open(filename, O_RDONLY|O_BINARY);

# if (dll < 1)

# return 1;

# dll_name = filename;

# for (i=0; filename[i]; i++)

# if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':')

# dll_name = filename + i +1;

# pe_header_offset = pe_get32 (dll, 0x3c);

# opthdr_ofs = pe_header_offset + 4 + 20;

# num_entries = pe_get32 (dll, opthdr_ofs + 92);

# if (num_entries < 1) /* no exports */

# return 1;

# export_rva = pe_get32 (dll, opthdr_ofs + 96);

# export_size = pe_get32 (dll, opthdr_ofs + 100);

# nsections = pe_get16 (dll, pe_header_offset + 4 +2);

# secptr = (pe_header_offset + 4 + 20 +

# pe_get16 (dll, pe_header_offset + 4 + 16));

# expptr = 0;

# for (i = 0; i < nsections; i++)

# {

# char sname[8];

# unsigned long secptr1 = secptr + 40 * i;

# unsigned long vaddr = pe_get32 (dll, secptr1 + 12);

# unsigned long vsize = pe_get32 (dll, secptr1 + 16);

# unsigned long fptr = pe_get32 (dll, secptr1 + 20);

# lseek(dll, secptr1, SEEK_SET);

# read(dll, sname, 8);

# if (vaddr <= export_rva && vaddr+vsize > export_rva)

# {

# expptr = fptr + (export_rva - vaddr);

# if (export_rva + export_size > vaddr + vsize)

# export_size = vsize - (export_rva - vaddr);

# break;

# }

# expdata = (unsigned char*)malloc(export_size);

# lseek (dll, expptr, SEEK_SET);

# read (dll, expdata, export_size);

# erva = expdata - export_rva;

# Check to make sure the PIC flag actually works.

# nexp = pe_as32 (expdata+24);

# name_rvas = pe_as32 (expdata+32);

if test -n "$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)"; then

# printf ("EXPORTS\n");

AC_LIBTOOL_COMPILER_OPTION([if $compiler PIC flag $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) works],

# for (i = 0; i<nexp; i++)

_LT_AC_TAGVAR(lt_prog_compiler_pic_works, $1),

# {

[$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])], [],

# unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);

[case $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) in

# printf ("\t%s @ %ld ;\n", erva+name_rva, 1+ i);

"" | " "*) ;;

# }

*) _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)" ;;

esac],

# return 0;

[_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

# }

_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])

# /* impgen.c ends here */

case "$host_os" in

# For platforms which do not support PIC, -DPIC is meaningless:

*djgpp*)

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=

;;

_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])"

;;

esac

])

# AC_LIBTOOL_PROG_LD_SHLIBS([TAGNAME])

EOF

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

# See if the linker supports building shared libraries.

AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS],

[AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])

ifelse([$1],[CXX],[

_LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

case $host_os in

aix4* | aix5*)

# If we're using GNU nm, then we don't want the "-C" option.

# -C means demangle to AIX nm, but means don't demangle with GNU nm

if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

_LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'

else

_LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'

;;

pw32*)

_LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"

;;

cygwin* | mingw*)

;;

_LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'

;;

esac

],[

runpath_var=

_LT_AC_TAGVAR(allow_undefined_flag, $1)=

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no

_LT_AC_TAGVAR(archive_cmds, $1)=

_LT_AC_TAGVAR(archive_expsym_cmds, $1)=

_LT_AC_TAGVAR(old_archive_From_new_cmds, $1)=

_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)=

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

_LT_AC_TAGVAR(thread_safe_flag_spec, $1)=

_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_direct, $1)=no

_LT_AC_TAGVAR(hardcode_minus_L, $1)=no

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown

_LT_AC_TAGVAR(hardcode_automatic, $1)=no

_LT_AC_TAGVAR(module_cmds, $1)=

_LT_AC_TAGVAR(module_expsym_cmds, $1)=

_LT_AC_TAGVAR(always_export_symbols, $1)=no

_LT_AC_TAGVAR(export_symbols_cmds, $1)='$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

_LT_AC_TAGVAR(include_expsyms, $1)=

# exclude_expsyms can be an extended regexp 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'.

_LT_AC_TAGVAR(exclude_expsyms, $1)="_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

# We use sed instead of cat because bash on DJGPP gets confused if

cygwin* | mingw* | pw32*)

# if finds mixed CR/LF and LF-only lines. Since sed operates in

# FIXME: the MSVC++ port hasn't been tested in a loooong time

# text mode, it properly converts lines to CR/LF. This bash problem

# When not using gcc, we currently assume that we are using

# is reportedly fixed, but why not run on old versions too?

# Microsoft Visual C++.

sed '$q' "$ltmain" >> "${ofile}T" || (rm -f "${ofile}T"; exit 1)

if test "$GCC" != yes; then

with_gnu_ld=no

mv -f "${ofile}T" "$ofile" || \

(rm -f "$ofile" && cp "${ofile}T" "$ofile" && rm -f "${ofile}T")

chmod +x "$ofile"

;;

openbsd*)

with_gnu_ld=no

;;

esac

_LT_AC_TAGVAR(ld_shlibs, $1)=yes

])# _LT_AC_LTCONFIG_HACK

if test "$with_gnu_ld" = yes; then

# If archive_cmds runs LD, not CC, wlarc should be empty

wlarc='${wl}'

# See if GNU ld supports shared libraries.

# AC_LIBTOOL_DLOPEN - enable checks for dlopen support

case $host_os in

AC_DEFUN([AC_LIBTOOL_DLOPEN], [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])])

aix3* | aix4* | aix5*)

# On AIX/PPC, the GNU linker is very broken

if test "$host_cpu" != ia64; then

_LT_AC_TAGVAR(ld_shlibs, $1)=no

cat <<EOF 1>&2

*** Warning: the GNU linker, at least up to release 2.9.1, is reported

# AC_LIBTOOL_WIN32_DLL - declare package support for building win32 dll's

*** to be unable to reliably create shared libraries on AIX.

AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])])

*** 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 - implement the --enable-shared flag

# Usage: AC_ENABLE_SHARED[(DEFAULT)]

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

changequote(<<, >>)dnl

<< --enable-shared[=PKGS] build shared libraries [default=>>AC_ENABLE_SHARED_DEFAULT],

changequote([, ])dnl

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

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"

for pkg in $enableval; do

if test "X$pkg" = "X$p"; then

enable_shared=yes

done

IFS="$ac_save_ifs"

;;

esac],

enable_shared=AC_ENABLE_SHARED_DEFAULT)dnl

])

amigaos*)

# AC_DISABLE_SHARED - set the default shared flag to --disable-shared

_LT_AC_TAGVAR(archive_cmds, $1)='$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)'

AC_DEFUN([AC_DISABLE_SHARED],

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

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

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

AC_ENABLE_SHARED(no)])

# Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

# that the semantics of dynamic libraries on AmigaOS, at least up

# to version 4, is to share data among multiple programs linked

# with the same dynamic library. Since this doesn't match the

# behavior of shared libraries on other platforms, we can't use

# them.

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

beos*)

# AC_ENABLE_STATIC - implement the --enable-static flag

if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

# Usage: AC_ENABLE_STATIC[(DEFAULT)]

_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to

# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

# `yes'.

# support --undefined. This deserves some investigation. FIXME

AC_DEFUN([AC_ENABLE_STATIC],

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

[define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl

else

AC_ARG_ENABLE(static,

_LT_AC_TAGVAR(ld_shlibs, $1)=no

changequote(<<, >>)dnl

<< --enable-static[=PKGS] build static libraries [default=>>AC_ENABLE_STATIC_DEFAULT],

changequote([, ])dnl

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

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"

for pkg in $enableval; do

if test "X$pkg" = "X$p"; then

enable_static=yes

done

IFS="$ac_save_ifs"

;;

esac],

enable_static=AC_ENABLE_STATIC_DEFAULT)dnl

])

cygwin* | mingw* | pw32*)

# AC_DISABLE_STATIC - set the default static flag to --disable-static

# _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,

AC_DEFUN([AC_DISABLE_STATIC],

# as there is no search path for DLLs.

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

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

AC_ENABLE_STATIC(no)])

_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

_LT_AC_TAGVAR(always_export_symbols, $1)=no

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'

# If the export-symbols file already is a .def file (1st line

# is EXPORTS), use it as is; otherwise, prepend...

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then

cp $export_symbols $output_objdir/$soname.def;

else

echo EXPORTS > $output_objdir/$soname.def;

cat $export_symbols >> $output_objdir/$soname.def;

fi~

$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'

else

ld_shlibs=no

;;

netbsd*)

# AC_ENABLE_FAST_INSTALL - implement the --enable-fast-install flag

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

# Usage: AC_ENABLE_FAST_INSTALL[(DEFAULT)]

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to

wlarc=

# `yes'.

else

AC_DEFUN([AC_ENABLE_FAST_INSTALL],

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

[define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

AC_ARG_ENABLE(fast-install,

changequote(<<, >>)dnl

<< --enable-fast-install[=PKGS] optimize for fast installation [default=>>AC_ENABLE_FAST_INSTALL_DEFAULT],

changequote([, ])dnl

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

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"

for pkg in $enableval; do

if test "X$pkg" = "X$p"; then

enable_fast_install=yes

done

IFS="$ac_save_ifs"

;;

esac],

enable_fast_install=AC_ENABLE_FAST_INSTALL_DEFAULT)dnl

])

solaris* | sysv5*)

# AC_DISABLE_FAST_INSTALL - set the default to --disable-fast-install

if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then

AC_DEFUN([AC_DISABLE_FAST_INSTALL],

_LT_AC_TAGVAR(ld_shlibs, $1)=no

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

cat <<EOF 1>&2

AC_ENABLE_FAST_INSTALL(no)])

*** Warning: The releases 2.8.* of the GNU linker cannot reliably

# AC_LIBTOOL_PICMODE - implement the --with-pic flag

*** create shared libraries on Solaris systems. Therefore, libtool

# Usage: AC_LIBTOOL_PICMODE[(MODE)]

*** is disabling shared libraries support. We urge you to upgrade GNU

# Where MODE is either `yes' or `no'. If omitted, it defaults to

*** binutils to release 2.9.1 or newer. Another option is to modify

# `both'.

*** your PATH or compiler configuration so that the native linker is

AC_DEFUN([AC_LIBTOOL_PICMODE],

*** used, and then restart.

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

pic_mode=ifelse($#,1,$1,default)])

EOF

elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

else

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

sunos4*)

# AC_PATH_TOOL_PREFIX - find a file program which can recognise shared library

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

AC_DEFUN([AC_PATH_TOOL_PREFIX],

wlarc=

[AC_MSG_CHECKING([for $1])

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

[case $MAGIC_CMD in

/*)

lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.

;;

?:/*)

linux*)

lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.

if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_cmds, $1)="$tmp_archive_cmds"

supports_anon_versioning=no

case `$LD -v 2>/dev/null` in

*\ [01].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11

*\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...

*\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...

*\ 2.11.*) ;; # other 2.11 versions

*) supports_anon_versioning=yes ;;

esac

if test $supports_anon_versioning = yes; then

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~

cat $export_symbols | sed -e "s/$.*$/\1;/" >> $output_objdir/$libname.ver~

$echo "local: *; };" >> $output_objdir/$libname.ver~

$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'

else

_LT_AC_TAGVAR(archive_expsym_cmds, $1)="$tmp_archive_cmds"

else

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then

ac_save_MAGIC_CMD="$MAGIC_CMD"

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

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

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

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

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

_LT_AC_TAGVAR(ld_shlibs, $1)=no

cat <<EOF 1>&2

;;

esac

if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = yes; then

*** Warning: the command libtool uses to detect shared libraries,

runpath_var=LD_RUN_PATH

*** $file_magic_cmd, produces output that libtool cannot recognize.

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'

*** The result is that libtool may fail to recognize shared libraries

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

*** as such. This will affect the creation of libtool libraries that

# ancient GNU ld didn't support --whole-archive et. al.

*** depend on shared libraries, but programs linked with such libtool

if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then

*** libraries will work regardless of this problem. Nevertheless, you

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

*** may want to report the problem to your system manager and/or to

else

*** bug-libtool@gnu.org

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

else

# PORTME fill in a description of your system's linker (not GNU ld)

case $host_os in

aix3*)

_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

_LT_AC_TAGVAR(always_export_symbols, $1)=yes

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'

# Note: this linker hardcodes the directories in LIBPATH if there

# are no directories specified by -L.

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

if test "$GCC" = yes && test -z "$link_static_flag"; then

# Neither direct hardcoding nor static linking is supported with a

# broken collect2.

_LT_AC_TAGVAR(hardcode_direct, $1)=unsupported

;;

aix4* | aix5*)

EOF

if test "$host_cpu" = ia64; then

fi ;;

# On IA64, the linker does run time linking by default, so we don't

esac

# have to do anything special.

aix_use_runtimelinking=no

exp_sym_flag='-Bexport'

no_entry_flag=""

else

# If we're using GNU nm, then we don't want the "-C" option.

# -C means demangle to AIX nm, but means don't demangle with GNU nm

if $NM -V 2>&1 | grep 'GNU' > /dev/null; then

else

aix_use_runtimelinking=no

# Test if we are trying to use run time linking or normal

# AIX style linking. If -brtl is somewhere in LDFLAGS, we

# need to do runtime linking.

case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)

for ld_flag in $LDFLAGS; do

if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then

aix_use_runtimelinking=yes

break

done

esac

IFS="$ac_save_ifs"

MAGIC_CMD="$ac_save_MAGIC_CMD"

exp_sym_flag='-bexport'

;;

no_entry_flag='-bnoentry'

esac])

MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

if test -n "$MAGIC_CMD"; then

AC_MSG_RESULT($MAGIC_CMD)

else

AC_MSG_RESULT(no)

])

# When large executables or shared objects are built, AIX ld can

# have problems creating the table of contents. If linking a library

# or program results in "error TOC overflow" add -mminimal-toc to

# CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not

# enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

_LT_AC_TAGVAR(archive_cmds, $1)=''

# AC_PATH_MAGIC - find a file program which can recognise a shared library

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

AC_DEFUN([AC_PATH_MAGIC],

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'

[AC_REQUIRE([AC_CHECK_TOOL_PREFIX])dnl

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin:$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)

else

MAGIC_CMD=:

])

# AC_PROG_LD - find the path to the GNU or non-GNU linker

AC_DEFUN([AC_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

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

AC_REQUIRE([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR])dnl

ac_prog=ld

if test "$GCC" = yes; then

case $host_os in aix4.[012]|aix4.[012].*)

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

# We only want to do this on AIX 4.2 and lower, the check

AC_MSG_CHECKING([for ld used by GCC])

# below for broken collect2 doesn't work under 4.3+

case $host in

collect2name=`${CC} -print-prog-name=collect2`

*-*-mingw*)

if test -f "$collect2name" && \

# gcc leaves a trailing carriage return which upsets mingw

strings "$collect2name" | grep resolve_lib_name >/dev/null

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

then

# We have reworked collect2

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

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

else

# We have old collect2

_LT_AC_TAGVAR(hardcode_direct, $1)=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

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

esac

shared_flag='-shared'

case $ac_prog in

else

# Accept absolute paths.

# not using gcc

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

if test "$host_cpu" = ia64; then

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

# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release

# Canonicalize the path of ld

# chokes on -Wl,-G. The following line is correct:

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

shared_flag='-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

if test "$aix_use_runtimelinking" = yes; then

AC_MSG_CHECKING([for non-GNU ld])

shared_flag='${wl}-G'

AC_CACHE_VAL(lt_cv_path_LD,

[if test -z "$LD"; then

IFS="${IFS= }"; ac_save_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

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.

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

test "$with_gnu_ld" != no && break

else

shared_flag='${wl}-bM:SRE'

test "$with_gnu_ld" != yes && break

done

IFS="$ac_save_ifs"

else

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

fi])

LD="$lt_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_PROG_LD_GNU

])

# It seems that -bexpall does not export symbols beginning with

# AC_PROG_LD_GNU -

# underscore (_), so it is better to generate a list of symbols to export.

AC_DEFUN([AC_PROG_LD_GNU],

_LT_AC_TAGVAR(always_export_symbols, $1)=yes

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

if test "$aix_use_runtimelinking" = yes; then

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

# Warning - without using the other runtime loading flags (-brtl),

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

# -berok will link without error, but may produce a broken library.

lt_cv_prog_gnu_ld=yes

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'

# Determine the default libpath from the value encoded in an empty executable.

_LT_AC_SYS_LIBPATH_AIX

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

else

if test "$host_cpu" = ia64; then

lt_cv_prog_gnu_ld=no

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'

fi])

_LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"

with_gnu_ld=$lt_cv_prog_gnu_ld

])

else

# Determine the default libpath from the value encoded in an empty executable.

# AC_PROG_LD_RELOAD_FLAG - find reload flag for linker

_LT_AC_SYS_LIBPATH_AIX

# -- PORTME Some linkers may need a different reload flag.

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],

# Warning - without using the other run time loading flags,

[AC_CACHE_CHECK([for $LD option to reload object files], lt_cv_ld_reload_flag,

# -berok will link without error, but may produce a broken library.

[lt_cv_ld_reload_flag='-r'])

_LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'

reload_flag=$lt_cv_ld_reload_flag

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'

test -n "$reload_flag" && reload_flag=" $reload_flag"

# -bexpall does not export symbols beginning with underscore (_)

])

_LT_AC_TAGVAR(always_export_symbols, $1)=yes

# Exported symbols can be pulled into shared objects from archives

# AC_DEPLIBS_CHECK_METHOD - how to check for library dependencies

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '

# -- PORTME fill in with the dynamic library characteristics

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

AC_DEFUN([AC_DEPLIBS_CHECK_METHOD],

# This is similar to how AIX traditionally builds it's shared libraries.

[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 egrep 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.

case $host_os in

aix4* | aix5*)

lt_cv_deplibs_check_method=pass_all

;;

amigaos*)

beos*)

lt_cv_deplibs_check_method=pass_all

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

# see comment about different semantics on the GNU ld section

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

bsdi4*)

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'

lt_cv_file_magic_cmd='/usr/bin/file -L'

lt_cv_file_magic_test_file=/shlib/libc.so

;;

cygwin* | mingw* | pw32*)

# When not using gcc, we currently assume that we are using

lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'

# Microsoft Visual C++.

lt_cv_file_magic_cmd='$OBJDUMP -f'

# hardcode_libdir_flag_spec is actually meaningless, as there is

# no search path for DLLs.

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=' '

_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

# Tell ltmain to make .lib files, not .a files.

libext=lib

# Tell ltmain to make .dll files, not .so files.

shrext=".dll"

# FIXME: Setting linknames here is a bad hack.

_LT_AC_TAGVAR(archive_cmds, $1)='$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.

_LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='true'

# FIXME: Should let the user specify the lib program.

_LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs'

fix_srcfile_path='`cygpath -w "$srcfile"`'

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

;;

darwin* | rhapsody*)

if test "$GXX" = yes ; then

lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

lt_cv_file_magic_cmd='/usr/bin/file -L'

case "$host_os" in

rhapsody* | darwin1.[[012]])

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'

lt_cv_file_magic_test_file=`echo /System/Library/Frameworks/System.framework/Versions/*/System | head -1`

;;

*) # Darwin 1.3 on

if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'

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

;;

10.*)

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'

;;

esac

;;

freebsd*)

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

lt_int_apple_cc_single_mod=no

output_verbose_link_cmd='echo'

if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then

lt_int_apple_cc_single_mod=yes

if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'

else

_LT_AC_TAGVAR(module_cmds, $1)='$CC ${wl}-bind_at_load $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

if test "X$lt_int_apple_cc_single_mod" = Xyes ; then

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^$..*$,_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

else

_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

lt_cv_deplibs_check_method=pass_all

;;

dgux*)

gnu*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_deplibs_check_method=pass_all

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

freebsd1*)

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

# FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

# support. Future versions do this automatically, but an explicit c++rt0.o

# does not break anything, and helps significantly (at the cost of a little

# extra space).

freebsd2.2*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

# Unfortunately, older versions of FreeBSD 2 do not have this feature.

freebsd2*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

# FreeBSD 3 and greater uses gcc -shared to do shared libraries.

freebsd* | kfreebsd*-gnu)

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

hpux9*)

hpux10.20*|hpux11*)

if test "$GCC" = yes; then

lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'

_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'

lt_cv_file_magic_cmd=/usr/bin/file

else

lt_cv_file_magic_test_file=/usr/lib/libc.sl

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

# hardcode_minus_L: Not really in the search PATH,

# but as the default location of the library.

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

;;

hpux10* | hpux11*)

irix5* | irix6* | nonstopux*)

if test "$GCC" = yes -a "$with_gnu_ld" = no; then

case $host_os in

case "$host_cpu" in

irix5* | nonstopux*)

hppa*64*|ia64*)

# this will be overridden with pass_all, but let us keep it just in case

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"

;;

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'

case $LD in

;;

*-32|*"-32 ") libmagic=32-bit;;

*-n32|*"-n32 ") libmagic=N32;;

*-64|*"-64 ") libmagic=64-bit;;

*) libmagic=never-match;;

esac

else

# this will be overridden with pass_all, but let us keep it just in case

case "$host_cpu" in

lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[[1234]] dynamic lib MIPS - version 1"

hppa*64*|ia64*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags'

;;

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'

;;

esac

lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`

if test "$with_gnu_ld" = no; then

lt_cv_deplibs_check_method=pass_all

case "$host_cpu" in

hppa*64*)

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

_LT_AC_TAGVAR(hardcode_direct, $1)=no

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

ia64*)

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=no

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

# hardcode_minus_L: Not really in the search PATH,

# but as the default location of the library.

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

;;

# This must be Linux ELF.

linux-gnu*)

case $host_cpu in

lt_cv_deplibs_check_method=pass_all ;;

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'

# glibc up to 2.1.1 does not perform some relocations on ARM

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;;

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

# hardcode_minus_L: Not really in the search PATH,

# but as the default location of the library.

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

;;

esac

lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`

;;

irix5* | irix6* | nonstopux*)

if test "$GCC" = yes; then

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

else

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

;;

netbsd*)

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out

lt_cv_deplibs_check_method='match_pattern /lib[[^/\.]]+\.so\.[[0-9]]+\.[[0-9]]+$'

else

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF

lt_cv_deplibs_check_method='match_pattern /lib[[^/\.]]+\.so$'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

newsos6)

newos6*)

_LT_AC_TAGVAR(archive_cmds, $1)='$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)'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

lt_cv_file_magic_cmd=/usr/bin/file

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

lt_cv_file_magic_test_file=/usr/lib/libnls.so

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

openbsd*)

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

lt_cv_file_magic_cmd=/usr/bin/file

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`

if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

else

case $host_os in

openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

;;

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'

;;

esac

;;

os2*)

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

_LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

;;

osf3*)

if test "$GCC" = yes; then

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

else

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

;;

osf4* | osf5*) # as osf3* with the addition of -msym flag

osf3* | osf4* | osf5*)

if test "$GCC" = yes; then

# this will be overridden with pass_all, but let us keep it just in case

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'

lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

lt_cv_file_magic_test_file=/shlib/libc.so

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'

lt_cv_deplibs_check_method=pass_all

else

_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'

_LT_AC_TAGVAR(archive_cmds, $1)='$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'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~

# Both c and cxx compiler support -rpath directly

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:

;;

sco3.2v5*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_deplibs_check_method=pass_all

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'

runpath_var=LD_RUN_PATH

hardcode_runpath_var=yes

;;

solaris*)

_LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'

lt_cv_deplibs_check_method=pass_all

if test "$GCC" = yes; then

lt_cv_file_magic_test_file=/lib/libc.so

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

$CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'

else

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$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'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

case $host_os in

solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;

*) # Supported since Solaris 2.6 (maybe 2.5.1?)

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;

esac

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

;;

sunos4*)

sysv5uw[[78]]* | sysv4*uw2*)

if test "x$host_vendor" = xsequent; then

lt_cv_deplibs_check_method=pass_all

# Use $CC to link under sequent, because it throws in some extra .o

# files that make .init and .fini sections work.

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'

else

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_minus_L, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

sysv4)

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

case $host_vendor in

sni)

motorola)

_LT_AC_TAGVAR(archive_cmds, $1)='$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 (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes # is this really true???

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`

;;

siemens)

ncr)

## LD is ld it makes a PLAMLIB

lt_cv_deplibs_check_method=pass_all

## CC just makes a GrossModule.

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'

_LT_AC_TAGVAR(hardcode_direct, $1)=no

;;

motorola)

sequent)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_file_magic_cmd='/bin/file'

_LT_AC_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'

;;

esac

sni)

runpath_var='LD_RUN_PATH'

lt_cv_file_magic_cmd='/bin/file'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

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)

sysv4.3*)

lt_cv_deplibs_check_method=pass_all

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'

;;

esac

sysv4*MP*)

if test -d /usr/nec; then

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

runpath_var=LD_RUN_PATH

hardcode_runpath_var=yes

_LT_AC_TAGVAR(ld_shlibs, $1)=yes

;;

esac

])

file_magic_cmd=$lt_cv_file_magic_cmd

deplibs_check_method=$lt_cv_deplibs_check_method

])

sysv4.2uw2*)

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'

_LT_AC_TAGVAR(hardcode_direct, $1)=yes

_LT_AC_TAGVAR(hardcode_minus_L, $1)=no

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

hardcode_runpath_var=yes

runpath_var=LD_RUN_PATH

;;

sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)

# AC_PROG_NM - find the path to a BSD-compatible name lister

_LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z ${wl}text'

AC_DEFUN([AC_PROG_NM],

if test "$GCC" = yes; then

[AC_REQUIRE([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR])dnl

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

AC_MSG_CHECKING([for BSD-compatible nm])

AC_CACHE_VAL(lt_cv_path_NM,

[if test -n "$NM"; then

# Let the user override the test.

lt_cv_path_NM="$NM"

else

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

for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do

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

if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then

lt_cv_path_NM="$tmp_nm -B"

break

elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then

lt_cv_path_NM="$tmp_nm -p"

break

else

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but

continue # so that we can try to find one that supports BSD flags

runpath_var='LD_RUN_PATH'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

done

;;

IFS="$ac_save_ifs"

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

fi])

NM="$lt_cv_path_NM"

AC_MSG_RESULT([$NM])

])

sysv5*)

# AC_CHECK_LIBM - check for math library

_LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'

AC_DEFUN([AC_CHECK_LIBM],

# $CC -shared without GNU ld will not create a library from C++

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

# object files and a static libstdc++, better avoid it by now

LIBM=

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

case $host in

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

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

$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

# These system don't have libm

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

runpath_var='LD_RUN_PATH'

;;

*-ncr-sysv4.3*)

uts4*)

AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")

_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

AC_CHECK_LIB(m, main, LIBM="$LIBM -lm")

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no

;;

_LT_AC_TAGVAR(ld_shlibs, $1)=no

AC_CHECK_LIB(m, main, LIBM="-lm")

;;

esac

])

AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])

test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

variables_saved_for_relink="PATH $shlibpath_var $runpath_var"

if test "$GCC" = yes; then

variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"

# Do we need to explicitly link libc?

case "x$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)" in

x|xyes)

# Assume -lc should be added

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

if test "$enable_shared" = yes && test "$GCC" = yes; then

# AC_LIBLTDL_CONVENIENCE[(dir)] - sets LIBLTDL to the link flags for

case $_LT_AC_TAGVAR(archive_cmds, $1) in

# the libltdl convenience library and LTDLINCL to the include flags for

*'~'*)

# the libltdl header and adds --enable-ltdl-convenience to the

# FIXME: we may have to deal with multi-command sequences.

# configure arguments. Note that LIBLTDL and LTDLINCL are not

;;

# AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If DIR is not

'$CC '*)

# provided, it is assumed to be `libltdl'. LIBLTDL will be prefixed

# Test whether the compiler implicitly links with -lc since on some

# with '${top_builddir}/' and LTDLINCL will be prefixed with

# systems, -lgcc has to come before -lc. If gcc already passes -lc

# '${top_srcdir}/' (note the single quotes!). If your package is not

# to ld, don't add -lc before -lgcc.

# flat and you're not using automake, define top_builddir and

AC_MSG_CHECKING([whether -lc should be explicitly linked in])

# top_srcdir appropriately in the Makefiles.

$rm conftest*

AC_DEFUN([AC_LIBLTDL_CONVENIENCE],

printf "$lt_simple_compile_test_code" > conftest.$ac_ext

[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"

])

if AC_TRY_EVAL(ac_compile) 2>conftest.err; then

# AC_LIBLTDL_INSTALLABLE[(dir)] - sets LIBLTDL to the link flags for

soname=conftest

# the libltdl installable library and LTDLINCL to the include flags for

lib=conftest

# the libltdl header and adds --enable-ltdl-install to the configure

libobjs=conftest.$ac_objext

# arguments. Note that LIBLTDL and LTDLINCL are not AC_SUBSTed, nor is

deplibs=

# AC_CONFIG_SUBDIRS called. If DIR is not provided and an installed

wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)

# libltdl is not found, it is assumed to be `libltdl'. LIBLTDL will

compiler_flags=-v

# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed

linker_flags=-v

# with '${top_srcdir}/' (note the single quotes!). If your package is

verstring=

# not flat and you're not using automake, define top_builddir and

output_objdir=.

# top_srcdir appropriately in the Makefiles.

libname=conftest

# In the future, this macro may have to be called after AC_PROG_LIBTOOL.

lt_save_allow_undefined_flag=$_LT_AC_TAGVAR(allow_undefined_flag, $1)

AC_DEFUN([AC_LIBLTDL_INSTALLABLE],

_LT_AC_TAGVAR(allow_undefined_flag, $1)=

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

if AC_TRY_EVAL(_LT_AC_TAGVAR(archive_cmds, $1) 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1)

AC_CHECK_LIB(ltdl, main,

then

[test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

[if test x"$enable_ltdl_install" = xno; then

AC_MSG_WARN([libltdl not installed, but installation disabled])

else

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes

enable_ltdl_install=yes

_LT_AC_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag

])

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

cat conftest.err 1>&5

ac_configure_args="$ac_configure_args --enable-ltdl-install=no"

LIBLTDL="-lltdl"

$rm conftest*

LTDLINCL=

AC_MSG_RESULT([$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)])

;;

esac

;;

# For backwards non-gettext consistent compatibility...

esac

INCLTDL="$LTDLINCL"

])# AC_LIBTOOL_PROG_LD_SHLIBS

])

# _LT_AC_FILE_LTDLL_C

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

# Be careful that the start marker always follows a newline.

AC_DEFUN([_LT_AC_FILE_LTDLL_C], [

# /* ltdll.c starts here */

# #define WIN32_LEAN_AND_MEAN

# #include <windows.h>

# #undef WIN32_LEAN_AND_MEAN

# #include <stdio.h>

# #ifndef __CYGWIN__

# # ifdef __CYGWIN32__

# # define __CYGWIN__ __CYGWIN32__

# # endif

# #endif

# #ifdef __cplusplus

# extern "C" {

# #endif

# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);

# #ifdef __cplusplus

# }

# #endif

# #ifdef __CYGWIN__

# #include <cygwin/cygwin_dll.h>

# DECLARE_CYGWIN_DLL( DllMain );

# #endif

# HINSTANCE __hDllInstance_base;

# BOOL APIENTRY

# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)

# {

# __hDllInstance_base = hInst;

# return TRUE;

# }

# /* ltdll.c ends here */

])# _LT_AC_FILE_LTDLL_C

# _LT_AC_TAGVAR(VARNAME, [TAGNAME])

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

AC_DEFUN([_LT_AC_TAGVAR], [ifelse([$2], [], [$1], [$1_$2])])

# old names

AC_DEFUN([AM_PROG_LIBTOOL], [AC_PROG_LIBTOOL])

Line 6866

Line 4442

# This is just to silence aclocal about the macro not being used

ifelse([AC_DISABLE_FAST_INSTALL])

AC_DEFUN([LT_AC_PROG_GCJ],

[AC_CHECK_TOOL(GCJ, gcj, no)

test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"

AC_SUBST(GCJFLAGS)

])

AC_DEFUN([LT_AC_PROG_RC],

[AC_CHECK_TOOL(RC, windres, no)

])

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

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

# a released version of Autoconf we should remove this #

Line 6889

Line 4455

AC_CACHE_VAL(lt_cv_path_SED,

[# Loop through the user's path and test for sed and gsed.

# Then use that list of sed's as ones to test for truncation.

as_executable_p="test -f"

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

for as_dir in $PATH

IFS=$as_save_IFS

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

for lt_ac_prog in sed gsed; do

for ac_prog in sed gsed; do

for ac_exec_ext in '' $ac_executable_extensions; do

if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then

if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then

lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"

_sed_list="$_sed_list $as_dir/$ac_prog$ac_exec_ext"

done

lt_ac_max=0

lt_ac_count=0

# Create a temporary directory, and hook for its removal unless debugging.

$debug ||

{

trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0

trap '{ (exit 1); exit 1; }' 1 2 13 15

}

# Create a (secure) tmp directory for tmp files.

: ${TMPDIR=/tmp}

{

tmp=`(umask 077 && mktemp -d -q "$TMPDIR/sedXXXXXX") 2>/dev/null` &&

test -n "$tmp" && test -d "$tmp"

} ||

{

tmp=$TMPDIR/sed$$-$RANDOM

(umask 077 && mkdir $tmp)

} ||

{

echo "$me: cannot create a temporary directory in $TMPDIR" >&2

{ (exit 1); exit 1; }

}

_max=0

_count=0

# Add /usr/xpg4/bin/sed as it is typically found on Solaris

# along with /bin/sed that truncates output.

for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do

for _sed in $_sed_list /usr/xpg4/bin/sed; do

test ! -f $lt_ac_sed && break

test ! -f ${_sed} && break

cat /dev/null > conftest.in

cat /dev/null > "$tmp/sed.in"

lt_ac_count=0

_count=0

echo $ECHO_N "0123456789$ECHO_C" >conftest.in

echo ${ECHO_N-$ac_n} "0123456789${ECHO_C-$ac_c}" >"$tmp/sed.in"

# Check for GNU sed and select it if it is found.

if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then

if "${_sed}" --version 2>&1 < /dev/null | egrep '(GNU)' > /dev/null; then

lt_cv_path_SED=$lt_ac_sed

lt_cv_path_SED=${_sed}

break

while true; do

cat conftest.in conftest.in >conftest.tmp

cat "$tmp/sed.in" "$tmp/sed.in" >"$tmp/sed.tmp"

mv conftest.tmp conftest.in

mv "$tmp/sed.tmp" "$tmp/sed.in"

cp conftest.in conftest.nl

cp "$tmp/sed.in" "$tmp/sed.nl"

echo >>conftest.nl

echo >>"$tmp/sed.nl"

$lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break

${_sed} -e 's/a$//' < "$tmp/sed.nl" >"$tmp/sed.out" || break

cmp -s conftest.out conftest.nl || break

cmp -s "$tmp/sed.out" "$tmp/sed.nl" || break

# 10000 chars as input seems more than enough

# 40000 chars as input seems more than enough

test $lt_ac_count -gt 10 && break

test $_count -gt 10 && break

lt_ac_count=`expr $lt_ac_count + 1`

_count=`expr $_count + 1`

if test $lt_ac_count -gt $lt_ac_max; then

if test $_count -gt $_max; then

lt_ac_max=$lt_ac_count

_max=$_count

lt_cv_path_SED=$lt_ac_sed

lt_cv_path_SED=$_sed

done

SED=$lt_cv_path_SED

rm -rf "$tmp"

])

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

lt_cv_path_SED=$SED

else

SED=$lt_cv_path_SED

AC_MSG_RESULT([$SED])

])

dnl AM_PROG_LEX

dnl Look for flex, lex or missing, then run AC_PROG_LEX and AC_DECL_YYTEXT

AC_DEFUN([AM_PROG_LEX],

[missing_dir=ifelse([$1],,`cd $ac_aux_dir && pwd`,$1)

AC_CHECK_PROGS(LEX, flex lex, "$missing_dir/missing flex")

AC_PROG_LEX

AC_DECL_YYTEXT])

# Define a conditional.

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

AC_DEFUN([AM_CONDITIONAL],

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

[AC_SUBST($1_TRUE)

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

AC_SUBST($1_FALSE)

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

if $2; then

# GNU General Public License for more details.

$1_TRUE=

$1_FALSE='#'

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

else

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

$1_TRUE='#'

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

$1_FALSE=

# 02111-1307, USA.

# serial 3

AC_PREREQ(2.50)

# AM_PROG_LEX

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

# Autoconf leaves LEX=: if lex or flex can't be found. Change that to a

# "missing" invocation, for better error output.

AC_DEFUN([AM_PROG_LEX],

[AC_REQUIRE([AM_MISSING_HAS_RUN])dnl

AC_REQUIRE([AC_PROG_LEX])dnl

if test "$LEX" = :; then

LEX=${am_missing_run}flex

fi])

Legend:

line(s) removed in v.1.12
line(s) changed
	line(s) added in v.1.13

File made using version 1.98 of cvs2html by leaf at 2011-07-21 16:53