Diff for /aclocal.m4 between versions 1.81 and 1.81.2.4

</
version 1.81, 2004/11/03 20:11:18 version 1.81.2.4, 2005/11/03 18:02:53
Line 1 Line 1
 dnl aclocal.m4 generated automatically by aclocal 1.4a  # generated automatically by aclocal 1.9.6 -*- Autoconf -*-
   
 dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.  # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 dnl This file is free software; the Free Software Foundation  # 2005  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.
   
 dnl Copyright 1998-2004 The OpenLDAP Foundation.  # Copyright (C) 2002, 2003, 2005  Free Software Foundation, Inc.
 dnl All rights reserved.  #
 dnl  # This file is free software; the Free Software Foundation
 dnl Redistribution and use in source and binary forms, with or without  # gives unlimited permission to copy and/or distribute it,
 dnl modification, are permitted only as authorized by the OpenLDAP  # with or without modifications, as long as this notice is preserved.
 dnl Public License.  
 dnl  # AM_AUTOMAKE_VERSION(VERSION)
 dnl A copy of this license is available in the file LICENSE in the  # ----------------------------
 dnl top-level directory of the distribution or, alternatively, at  # Automake X.Y traces this macro to ensure aclocal.m4 has been
 dnl <http://www.OpenLDAP.org/license.html>.  # generated from the m4 files accompanying Automake X.Y.
 divert(-1)  AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.9"])
 builtin(include, build/openldap.m4)dnl  
   # AM_SET_CURRENT_AUTOMAKE_VERSION
 # Do all the work for Automake.  This macro actually does too much --  # -------------------------------
 # some checks are only needed if your package does certain things.  # Call AM_AUTOMAKE_VERSION so it can be traced.
 # But this isn't really a big deal.  # This function is AC_REQUIREd by AC_INIT_AUTOMAKE.
   AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
 # serial 1           [AM_AUTOMAKE_VERSION([1.9.6])])
   
 dnl Usage:  # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
 dnl AM_INIT_AUTOMAKE(package,version, [no-define])  
   # Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
 AC_DEFUN(AM_INIT_AUTOMAKE,  #
 [AC_REQUIRE([AC_PROG_INSTALL])  # This file is free software; the Free Software Foundation
 dnl We require 2.13 because we rely on SHELL being computed by configure.  # gives unlimited permission to copy and/or distribute it,
 AC_PREREQ([2.13])  # with or without modifications, as long as this notice is preserved.
 PACKAGE=[$1]  
 AC_SUBST(PACKAGE)  # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
 VERSION=[$2]  # $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
 AC_SUBST(VERSION)  # `$srcdir', `$srcdir/..', or `$srcdir/../..'.
 dnl test to see if srcdir already configured  #
 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then  # Of course, Automake must honor this variable whenever it calls a
   AC_MSG_ERROR([source directory already configured; run "make distclean" there first])  # 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.
   
   AC_DEFUN([AM_AUX_DIR_EXPAND],
   [dnl Rely on autoconf to set up CDPATH properly.
   AC_PREREQ([2.50])dnl
   # expand $ac_aux_dir to an absolute path
   am_aux_dir=`cd $ac_aux_dir && pwd`
   ])
   
   # AM_CONDITIONAL                                            -*- Autoconf -*-
   
   # Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005
   # Free Software Foundation, Inc.
   #
   # This file is free software; the Free Software Foundation
   # gives unlimited permission to copy and/or distribute it,
   # with or without modifications, as long as this notice is preserved.
   
   # serial 7
   
   # AM_CONDITIONAL(NAME, SHELL-CONDITION)
   # -------------------------------------
   # Define a conditional.
   AC_DEFUN([AM_CONDITIONAL],
   [AC_PREREQ(2.52)dnl
    ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
           [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
   AC_SUBST([$1_TRUE])
   AC_SUBST([$1_FALSE])
   if $2; then
     $1_TRUE=
     $1_FALSE='#'
   else
     $1_TRUE='#'
     $1_FALSE=
 fi  fi
 ifelse([$3],,  AC_CONFIG_COMMANDS_PRE(
 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])  [if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
 AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))    AC_MSG_ERROR([[conditional "$1" was never defined.
 AC_REQUIRE([AM_SANITY_CHECK])  Usually this means the macro was only invoked conditionally.]])
 AC_REQUIRE([AC_ARG_PROGRAM])  fi])])
 dnl FIXME This is truly gross.  
 missing_dir=`cd $ac_aux_dir && pwd`  
 AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)  # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
 AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)  # Free Software Foundation, Inc.
 AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)  #
 AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)  # This file is free software; the Free Software Foundation
 AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)  # gives unlimited permission to copy and/or distribute it,
 dnl Set install_sh for make dist  # with or without modifications, as long as this notice is preserved.
 install_sh="$missing_dir/install-sh"  
 test -f "$install_sh" || install_sh="$missing_dir/install.sh"  # serial 8
 AC_SUBST(install_sh)  
 dnl We check for tar when the user configures the end package.  # There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
 dnl This is sad, since we only need this for "dist".  However,  # written in clear, in which case automake, when reading aclocal.m4,
 dnl there's no other good way to do it.  We prefer GNU tar if  # will think it sees a *use*, and therefore will trigger all it's
 dnl we can find it.  If we can't find a tar, it doesn't really matter.  # C support machinery.  Also note that it means that autoscan, seeing
 AC_CHECK_PROGS(AMTAR, gnutar gtar tar)  # CC etc. in the Makefile, will ask for an AC_PROG_CC use...
 dnl We need awk for the "check" target.  The system "awk" is bad on  
 dnl some platforms.  
 AC_REQUIRE([AC_PROG_AWK])  # _AM_DEPENDENCIES(NAME)
 AMTARFLAGS=  # ----------------------
 if test -n "$AMTAR"; then  # See how the compiler implements dependency checking.
   if $SHELL -c "$AMTAR --version" > /dev/null 2>&1; then  # NAME is "CC", "CXX", "GCJ", or "OBJC".
     dnl We have GNU tar.  # We try a few techniques and use that to set a single cache variable.
     AMTARFLAGS=o  #
   # We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
   # modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
   # dependency, and given that the user is not expected to run this macro,
   # just rely on AC_PROG_CC.
   AC_DEFUN([_AM_DEPENDENCIES],
   [AC_REQUIRE([AM_SET_DEPDIR])dnl
   AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
   AC_REQUIRE([AM_MAKE_INCLUDE])dnl
   AC_REQUIRE([AM_DEP_TRACK])dnl
   
   ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
          [$1], CXX,  [depcc="$CXX"  am_compiler_list=],
          [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
          [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
                      [depcc="$$1"   am_compiler_list=])
   
   AC_CACHE_CHECK([dependency style of $depcc],
                  [am_cv_$1_dependencies_compiler_type],
   [if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
     # We make a subdir and do the tests there.  Otherwise we can end up
     # making bogus files that we don't know about and never remove.  For
     # instance it was reported that on HP-UX the gcc test will end up
     # making a dummy file named `D' -- because `-MD' means `put the output
     # in D'.
     mkdir conftest.dir
     # Copy depcomp to subdir because otherwise we won't find it if we're
     # using a relative directory.
     cp "$am_depcomp" conftest.dir
     cd conftest.dir
     # We will build objects and dependencies in a subdirectory because
     # it helps to detect inapplicable dependency modes.  For instance
     # both Tru64's cc and ICC support -MD to output dependencies as a
     # side effect of compilation, but ICC will put the dependencies in
     # the current directory while Tru64 will put them in the object
     # directory.
     mkdir sub
   
     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`
   fi    fi
     for depmode in $am_compiler_list; do
       # Setup a source with many dependencies, because some compilers
       # like to wrap large dependency lists on column 80 (with \), and
       # we should not choose a depcomp mode which is confused by this.
       #
       # 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.
       : > sub/conftest.c
       for i in 1 2 3 4 5 6; do
         echo '#include "conftst'$i'.h"' >> sub/conftest.c
         # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
         # Solaris 8's {/usr,}/bin/sh.
         touch sub/conftst$i.h
       done
       echo "${am__include} ${am__quote}sub/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
         fi
         ;;
       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=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
          depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
          $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
            >/dev/null 2>conftest.err &&
          grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
          grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
          ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
         # icc doesn't choke on unknown options, it will just issue warnings
         # or remarks (even with -Werror).  So we grep stderr for any message
         # that says an option was ignored or not supported.
         # When given -MP, icc 7.0 and 7.1 complain thusly:
         #   icc: Command line warning: ignoring option '-M'; no argument required
         # The diagnosis changed in icc 8.0:
         #   icc: Command line remark: option '-MP' not supported
         if (grep 'ignoring option' conftest.err ||
             grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
           am_cv_$1_dependencies_compiler_type=$depmode
           break
         fi
       fi
     done
   
     cd ..
     rm -rf conftest.dir
   else
     am_cv_$1_dependencies_compiler_type=none
   fi
   ])
   AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
   AM_CONDITIONAL([am__fastdep$1], [
     test "x$enable_dependency_tracking" != xno \
     && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
   ])
   
   
   # AM_SET_DEPDIR
   # -------------
   # Choose a directory name for dependency files.
   # This macro is AC_REQUIREd in _AM_DEPENDENCIES
   AC_DEFUN([AM_SET_DEPDIR],
   [AC_REQUIRE([AM_SET_LEADING_DOT])dnl
   AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
   ])
   
   
   # AM_DEP_TRACK
   # ------------
   AC_DEFUN([AM_DEP_TRACK],
   [AC_ARG_ENABLE(dependency-tracking,
   [  --disable-dependency-tracking  speeds up one-time build
     --enable-dependency-tracking   do not reject slow dependency extractors])
   if test "x$enable_dependency_tracking" != xno; then
     am_depcomp="$ac_aux_dir/depcomp"
     AMDEPBACKSLASH='\'
 fi  fi
 AC_SUBST(AMTARFLAGS)  AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
 AC_REQUIRE([AC_PROG_MAKE_SET])])  AC_SUBST([AMDEPBACKSLASH])
   ])
   
   # Generate code to set up dependency tracking.              -*- Autoconf -*-
   
   # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
   # Free Software Foundation, Inc.
 #  #
 # Check to make sure that the build environment is sane.  # This file is free software; the Free Software Foundation
   # gives unlimited permission to copy and/or distribute it,
   # with or without modifications, as long as this notice is preserved.
   
   #serial 3
   
   # _AM_OUTPUT_DEPENDENCY_COMMANDS
   # ------------------------------
   AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
   [for mf in $CONFIG_FILES; do
     # Strip MF so we end up with the name of the file.
     mf=`echo "$mf" | sed -e 's/:.*$//'`
     # Check whether this is an Automake generated Makefile or not.
     # We used to match only the files named `Makefile.in', but
     # some people rename them; so instead we look at the file content.
     # Grep'ing the first line is not enough: some people post-process
     # each Makefile.in and add a new line on top of each file to say so.
     # So let's grep whole file.
     if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
       dirpart=`AS_DIRNAME("$mf")`
     else
       continue
     fi
     # Extract the definition of DEPDIR, am__include, and am__quote
     # from the Makefile without running `make'.
     DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
     test -z "$DEPDIR" && continue
     am__include=`sed -n 's/^am__include = //p' < "$mf"`
     test -z "am__include" && continue
     am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
     # When using ansi2knr, U may be empty or an underscore; expand it
     U=`sed -n 's/^U = //p' < "$mf"`
     # Find all dependency output files, they are included files with
     # $(DEPDIR) in their names.  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 "
       s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/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
   done
   ])# _AM_OUTPUT_DEPENDENCY_COMMANDS
   
   
   # AM_OUTPUT_DEPENDENCY_COMMANDS
   # -----------------------------
   # This macro should only be invoked once -- use via AC_REQUIRE.
 #  #
   # This code is only required when automatic dependency tracking
   # is enabled.  FIXME.  This creates each `.P' file that we will
   # need in order to bootstrap the dependency handling code.
   AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
   [AC_CONFIG_COMMANDS([depfiles],
        [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
        [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
   ])
   
 AC_DEFUN(AM_SANITY_CHECK,  # Do all the work for Automake.                             -*- Autoconf -*-
 [AC_MSG_CHECKING([whether build environment is sane])  
 # Just in case  
 sleep 1  
 echo timestamp > conftestfile  
 # Do `set' in a subshell so we don't clobber the current shell's  
 # arguments.  Must try -L first in case configure is actually a  
 # symlink; some systems play weird games with the mod time of symlinks  
 # (eg FreeBSD returns the mod time of the symlink's containing  
 # directory).  
 if (  
    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`  
    if test "[$]*" = "X"; then  
       # -L didn't work.  
       set X `ls -t $srcdir/configure conftestfile`  
    fi  
    if test "[$]*" != "X $srcdir/configure conftestfile" \  
       && test "[$]*" != "X conftestfile $srcdir/configure"; then  
   
       # If neither matched, then we have a broken ls.  This can happen  # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
       # if, for instance, CONFIG_SHELL is bash and it inherits a  # Free Software Foundation, Inc.
       # broken ls alias from the environment.  This has actually  #
       # happened.  Such a system could not be considered "sane".  # This file is free software; the Free Software Foundation
       AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken  # gives unlimited permission to copy and/or distribute it,
 alias in your environment])  # with or without modifications, as long as this notice is preserved.
    fi  
   # serial 12
   
   # This macro actually does too much.  Some checks are only needed if
   # your package does certain things.  But this isn't really a big deal.
   
   # 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_PREREQ([2.58])dnl
   dnl Autoconf wants to disallow AM_ names.  We explicitly allow
   dnl the ones we care about.
   m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
   AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
   AC_REQUIRE([AC_PROG_INSTALL])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])
   fi
   
    test "[$]2" = conftestfile  # test whether we have cygpath
    )  if test -z "$CYGPATH_W"; then
 then    if (cygpath --version) >/dev/null 2>/dev/null; then
    # Ok.      CYGPATH_W='cygpath -w'
    :    else
 else      CYGPATH_W=echo
    AC_MSG_ERROR([newly created file is older than distributed files!    fi
 Check your system clock])  
 fi  fi
 rm -f conftest*  AC_SUBST([CYGPATH_W])
 AC_MSG_RESULT(yes)])  
   # Define the identity of the package.
   dnl Distinguish between old-style and new-style calls.
   m4_ifval([$2],
   [m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
    AC_SUBST([PACKAGE], [$1])dnl
    AC_SUBST([VERSION], [$2])],
   [_AM_SET_OPTIONS([$1])dnl
    AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
    AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
   
   _AM_IF_OPTION([no-define],,
   [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_PROG_INSTALL_SH
   AM_PROG_INSTALL_STRIP
   AC_REQUIRE([AM_PROG_MKDIR_P])dnl
   # 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
   AC_REQUIRE([AM_SET_LEADING_DOT])dnl
   _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
                 [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
                                [_AM_PROG_TAR([v7])])])
   _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
   ])
   ])
   
 dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)  
 dnl The program must properly implement --version.  # When config.status generates a header, we must update the stamp-h file.
 AC_DEFUN(AM_MISSING_PROG,  # This file resides in the same directory as the config header
 [AC_MSG_CHECKING(for working $2)  # that is generated.  The stamp files are numbered to have different names.
 # Run test in a subshell; some versions of sh will print an error if  
 # an executable is not found, even if stderr is redirected.  # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
 # Redirect stdin to placate older versions of autoconf.  Sigh.  # loop where config.status creates the headers, so we can generate
 if ($2 --version) < /dev/null > /dev/null 2>&1; then  # our stamp files there.
    $1=$2  AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
    AC_MSG_RESULT(found)  [# Compute $1's index in $config_headers.
   _am_stamp_count=1
   for _am_header in $config_headers :; do
     case $_am_header in
       $1 | $1:* )
         break ;;
       * )
         _am_stamp_count=`expr $_am_stamp_count + 1` ;;
     esac
   done
   echo "timestamp for $1" >`AS_DIRNAME([$1])`/stamp-h[]$_am_stamp_count])
   
   # Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
   #
   # This file is free software; the Free Software Foundation
   # gives unlimited permission to copy and/or distribute it,
   # with or without modifications, as long as this notice is preserved.
   
   # AM_PROG_INSTALL_SH
   # ------------------
   # Define $install_sh.
   AC_DEFUN([AM_PROG_INSTALL_SH],
   [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
   install_sh=${install_sh-"$am_aux_dir/install-sh"}
   AC_SUBST(install_sh)])
   
   # Copyright (C) 2003, 2005  Free Software Foundation, Inc.
   #
   # This file is free software; the Free Software Foundation
   # gives unlimited permission to copy and/or distribute it,
   # with or without modifications, as long as this notice is preserved.
   
   # serial 2
   
   # Check whether the underlying file-system supports filenames
   # with a leading dot.  For instance MS-DOS doesn't.
   AC_DEFUN([AM_SET_LEADING_DOT],
   [rm -rf .tst 2>/dev/null
   mkdir .tst 2>/dev/null
   if test -d .tst; then
     am__leading_dot=.
 else  else
    $1="$3/missing $2"    am__leading_dot=_
    AC_MSG_RESULT(missing)  
 fi  fi
 AC_SUBST($1)])  rmdir .tst 2>/dev/null
   AC_SUBST([am__leading_dot])])
   
   # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
   
 # libtool.m4 - Configure libtool for the host system. -*-Shell-script-*-  # serial 47 AC_PROG_LIBTOOL
   
 # serial 46 AC_PROG_LIBTOOL  
   
   # AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)
   # -----------------------------------------------------------
   # If this macro is not defined by Autoconf, define it here.
   m4_ifdef([AC_PROVIDE_IFELSE],
            [],
            [m4_define([AC_PROVIDE_IFELSE],
                    [m4_ifdef([AC_PROVIDE_$1],
                              [$2], [$3])])])
   
   
   # AC_PROG_LIBTOOL
   # ---------------
 AC_DEFUN([AC_PROG_LIBTOOL],  AC_DEFUN([AC_PROG_LIBTOOL],
   [AC_REQUIRE([_AC_PROG_LIBTOOL])dnl
   dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX
   dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX.
     AC_PROVIDE_IFELSE([AC_PROG_CXX],
       [AC_LIBTOOL_CXX],
       [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX
     ])])
   dnl And a similar setup for Fortran 77 support
     AC_PROVIDE_IFELSE([AC_PROG_F77],
       [AC_LIBTOOL_F77],
       [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77
   ])])
   
   dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly.
   dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run
   dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both.
     AC_PROVIDE_IFELSE([AC_PROG_GCJ],
       [AC_LIBTOOL_GCJ],
       [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
         [AC_LIBTOOL_GCJ],
         [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],
           [AC_LIBTOOL_GCJ],
         [ifdef([AC_PROG_GCJ],
                [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])
          ifdef([A][M_PROG_GCJ],
                [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])])
          ifdef([LT_AC_PROG_GCJ],
                [define([LT_AC_PROG_GCJ],
                   defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])])
   ])])# AC_PROG_LIBTOOL
   
   
   # _AC_PROG_LIBTOOL
   # ----------------
   AC_DEFUN([_AC_PROG_LIBTOOL],
 [AC_REQUIRE([AC_LIBTOOL_SETUP])dnl  [AC_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  # This can be used to rebuild libtool when needed
 LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"  LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"
Line 153  AC_SUBST(LIBTOOL)dnl Line 556  AC_SUBST(LIBTOOL)dnl
   
 # Prevent multiple expansion  # Prevent multiple expansion
 define([AC_PROG_LIBTOOL], [])  define([AC_PROG_LIBTOOL], [])
 ])  ])# _AC_PROG_LIBTOOL
   
   
   # AC_LIBTOOL_SETUP
   # ----------------
 AC_DEFUN([AC_LIBTOOL_SETUP],  AC_DEFUN([AC_LIBTOOL_SETUP],
 [AC_PREREQ(2.13)dnl  [AC_PREREQ(2.50)dnl
 AC_REQUIRE([AC_ENABLE_SHARED])dnl  AC_REQUIRE([AC_ENABLE_SHARED])dnl
 AC_REQUIRE([AC_ENABLE_STATIC])dnl  AC_REQUIRE([AC_ENABLE_STATIC])dnl
 AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl  AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl
Line 166  AC_REQUIRE([AC_PROG_CC])dnl Line 572  AC_REQUIRE([AC_PROG_CC])dnl
 AC_REQUIRE([AC_PROG_LD])dnl  AC_REQUIRE([AC_PROG_LD])dnl
 AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl  AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl
 AC_REQUIRE([AC_PROG_NM])dnl  AC_REQUIRE([AC_PROG_NM])dnl
 AC_REQUIRE([LT_AC_PROG_SED])dnl  
   
 AC_REQUIRE([AC_PROG_LN_S])dnl  AC_REQUIRE([AC_PROG_LN_S])dnl
 AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl  AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl
   # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
 AC_REQUIRE([AC_OBJEXT])dnl  AC_REQUIRE([AC_OBJEXT])dnl
 AC_REQUIRE([AC_EXEEXT])dnl  AC_REQUIRE([AC_EXEEXT])dnl
 dnl  dnl
   
 _LT_AC_PROG_ECHO_BACKSLASH  AC_LIBTOOL_SYS_MAX_CMD_LEN
 # Only perform the check for file, if the check method requires it  AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
 case $deplibs_check_method in  AC_LIBTOOL_OBJDIR
 file_magic*)  
   if test "$file_magic_cmd" = '$MAGIC_CMD'; then  
     AC_PATH_MAGIC  
   fi  
   ;;  
 esac  
   
 AC_CHECK_TOOL(RANLIB, ranlib, :)  
 AC_CHECK_TOOL(STRIP, strip, :)  
   
 ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)  
 ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],  
 enable_win32_dll=yes, enable_win32_dll=no)  
   
 AC_ARG_ENABLE(libtool-lock,  
   [  --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  AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
 # libtool support.  _LT_AC_PROG_ECHO_BACKSLASH
 case $host in  
 *-*-irix6*)  
   # Find out which ABI we are using.  
   echo '[#]line __oline__ "configure"' > conftest.$ac_ext  
   if AC_TRY_EVAL(ac_compile); then  
     case `/usr/bin/file conftest.$ac_objext` in  
     *32-bit*)  
       LD="${LD-ld} -32"  
       ;;  
     *N32*)  
       LD="${LD-ld} -n32"  
       ;;  
     *64-bit*)  
       LD="${LD-ld} -64"  
       ;;  
     esac  
   fi  
   rm -rf conftest*  
   ;;  
   
 *-*-sco3.2v5*)  case $host_os in
   # On SCO OpenServer 5, we need -belf to get full-featured binaries.  aix3*)
   SAVE_CFLAGS="$CFLAGS"    # AIX sometimes has problems with the GCC collect2 program.  For some
   CFLAGS="$CFLAGS -belf"    # reason, if we set the COLLECT_NAMES environment variable, the problems
   AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,    # vanish in a puff of smoke.
     [AC_LANG_SAVE    if test "X${COLLECT_NAMES+set}" != Xset; then
      AC_LANG_C      COLLECT_NAMES=
      AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])      export COLLECT_NAMES
      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"  
   fi    fi
   ;;    ;;
   
 ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],  
 [*-*-cygwin* | *-*-mingw* | *-*-pw32*)  
   AC_CHECK_TOOL(DLLTOOL, dlltool, false)  
   AC_CHECK_TOOL(AS, as, false)  
   AC_CHECK_TOOL(OBJDUMP, objdump, false)  
   
   # recent cygwin and mingw systems supply a stub DllMain which the user  
   # can override, but on older systems we have to supply one  
   AC_CACHE_CHECK([if libtool should supply DllMain function], lt_cv_need_dllmain,  
     [AC_TRY_LINK([],  
       [extern int __attribute__((__stdcall__)) DllMain(void*, int, void*);  
       DllMain (0, 0, 0);],  
       [lt_cv_need_dllmain=no],[lt_cv_need_dllmain=yes])])  
   
   case $host/$CC in  
   *-*-cygwin*/gcc*-mno-cygwin*|*-*-mingw*)  
     # old mingw systems require "-dll" to link a DLL, while more recent ones  
     # require "-mdll"  
     SAVE_CFLAGS="$CFLAGS"  
     CFLAGS="$CFLAGS -mdll"  
     AC_CACHE_CHECK([how to link DLLs], lt_cv_cc_dll_switch,  
       [AC_TRY_LINK([], [], [lt_cv_cc_dll_switch=-mdll],[lt_cv_cc_dll_switch=-dll])])  
     CFLAGS="$SAVE_CFLAGS" ;;  
   *-*-cygwin* | *-*-pw32*)  
     # cygwin systems need to pass --dll to the linker, and not link  
     # crt.o which will require a WinMain@16 definition.  
     lt_cv_cc_dll_switch="-Wl,--dll -nostartfiles" ;;  
   esac  
   ;;  
   ])  
 esac  esac
   
 _LT_AC_LTCONFIG_HACK  # Sed substitution that helps us do robust quoting.  It backslashifies
   # metacharacters that are still active within double-quoted strings.
   Xsed='sed -e 1s/^X//'
   [sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
   
 ])  # Same as above, but do not quote variable references.
   [double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']
   
 # AC_LIBTOOL_HEADER_ASSERT  # Sed substitution to delay expansion of an escaped shell variable in a
 # ------------------------  # double_quote_subst'ed string.
 AC_DEFUN([AC_LIBTOOL_HEADER_ASSERT],  delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
 [AC_CACHE_CHECK([whether $CC supports assert without backlinking],  
     [lt_cv_func_assert_works],  
     [case $host in  
     *-*-solaris*)  
       if test "$GCC" = yes && test "$with_gnu_ld" != yes; then  
         case `$CC --version 2>/dev/null` in  
         [[12]].*) lt_cv_func_assert_works=no ;;  
         *)        lt_cv_func_assert_works=yes ;;  
         esac  
       fi  
       ;;  
     esac])  
   
 if test "x$lt_cv_func_assert_works" = xyes; then  # Sed substitution to avoid accidental globbing in evaled expressions
   AC_CHECK_HEADERS(assert.h)  no_glob_subst='s/\*/\\\*/g'
 fi  
 ])# AC_LIBTOOL_HEADER_ASSERT  
   
 # _LT_AC_CHECK_DLFCN  # Constants:
 # --------------------  rm="rm -f"
 AC_DEFUN([_LT_AC_CHECK_DLFCN],  
 [AC_CHECK_HEADERS(dlfcn.h)  
 ])# _LT_AC_CHECK_DLFCN  
   
 # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE  # Global variables:
 # ---------------------------------  default_ofile=libtool
 AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],  can_build_shared=yes
 [AC_REQUIRE([AC_CANONICAL_HOST])  
 AC_REQUIRE([AC_PROG_NM])  
 AC_REQUIRE([AC_OBJEXT])  
 # Check for command to grab the raw symbol name followed by C symbol from nm.  
 AC_MSG_CHECKING([command to parse $NM output])  
 AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [dnl  
   
 # These are sane defaults that work on at least a few old systems.  # All known linkers require a `.a' archive for static linking (except MSVC,
 # [They come from Ultrix.  What could be older than Ultrix?!! ;)]  # which needs '.lib').
   libext=a
   ltmain="$ac_aux_dir/ltmain.sh"
   ofile="$default_ofile"
   with_gnu_ld="$lt_cv_prog_gnu_ld"
   
 # Character class describing NM global symbol codes.  AC_CHECK_TOOL(AR, ar, false)
 symcode='[[BCDEGRST]]'  AC_CHECK_TOOL(RANLIB, ranlib, :)
   AC_CHECK_TOOL(STRIP, strip, :)
   
 # Regexp to match symbols that can be accessed directly from C.  old_CC="$CC"
 sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'  old_CFLAGS="$CFLAGS"
   
 # Transform the above into a raw symbol and a C symbol.  # Set sane defaults for various variables
 symxfrm='\1 \2\3 \3'  test -z "$AR" && AR=ar
   test -z "$AR_FLAGS" && AR_FLAGS=cru
   test -z "$AS" && AS=as
   test -z "$CC" && CC=cc
   test -z "$LTCC" && LTCC=$CC
   test -z "$DLLTOOL" && DLLTOOL=dlltool
   test -z "$LD" && LD=ld
   test -z "$LN_S" && LN_S="ln -s"
   test -z "$MAGIC_CMD" && MAGIC_CMD=file
   test -z "$NM" && NM=nm
   test -z "$SED" && SED=sed
   test -z "$OBJDUMP" && OBJDUMP=objdump
   test -z "$RANLIB" && RANLIB=:
   test -z "$STRIP" && STRIP=:
   test -z "$ac_objext" && ac_objext=o
   
 # Transform an extracted symbol line into a proper C declaration  # Determine commands to create old-style static archives.
 lt_cv_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern char \1;/p'"  old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
   old_postinstall_cmds='chmod 644 $oldlib'
   old_postuninstall_cmds=
   
 # Transform an extracted symbol line into symbol name and symbol address  if test -n "$RANLIB"; then
 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'"    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"
   fi
   
 # Define system-specific variables.  _LT_CC_BASENAME([$compiler])
 case $host_os in  
 aix*)  
   symcode='[[BCDT]]'  
   ;;  
 cygwin* | mingw* | pw32*)  
   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  
   
 # Handle CRLF in mingw tool chain  # Only perform the check for file, if the check method requires it
 opt_cr=  case $deplibs_check_method in
 case $host_os in  file_magic*)
 mingw*)    if test "$file_magic_cmd" = '$MAGIC_CMD'; then
   opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp      AC_PATH_MAGIC
     fi
   ;;    ;;
 esac  esac
   
 # If we're using GNU nm, then use its standard symbol codes.  AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)
 if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then  AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
   symcode='[[ABCDGISTW]]'  enable_win32_dll=yes, enable_win32_dll=no)
 fi  
   
 # Try without a prefix undercore, then with it.  
 for ac_symprfx in "" "_"; do  
   
   # Write the raw and C identifiers.  AC_ARG_ENABLE([libtool-lock],
 lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[        ]]\($symcode$symcode*\)[[       ]][[    ]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"      [AC_HELP_STRING([--disable-libtool-lock],
           [avoid locking (might break parallel builds)])])
   test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
   
   # Check to see that the pipe works correctly.  AC_ARG_WITH([pic],
   pipe_works=no      [AC_HELP_STRING([--with-pic],
   rm -f conftest*          [try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
   cat > conftest.$ac_ext <<EOF      [pic_mode="$withval"],
 #ifdef __cplusplus      [pic_mode=default])
 extern "C" {  test -z "$pic_mode" && pic_mode=default
 #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  # Use C for the default configuration in the libtool script
     # Now try to grab the symbols.  tagname=
     nlist=conftest.nm  AC_LIBTOOL_LANG_C_CONFIG
     if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then  _LT_AC_TAGCONFIG
       # Try sorting and uniquifying the output.  ])# AC_LIBTOOL_SETUP
       if sort "$nlist" | uniq > "$nlist"T; then  
         mv -f "$nlist"T "$nlist"  
       else  
         rm -f "$nlist"T  
       fi  
   
       # Make sure that we snagged all the symbols we need.  
       if egrep ' nm_test_var$' "$nlist" >/dev/null; then  
         if egrep ' nm_test_func$' "$nlist" >/dev/null; then  
           cat <<EOF > conftest.$ac_ext  
 #ifdef __cplusplus  
 extern "C" {  
 #endif  
   
 EOF  # _LT_AC_SYS_COMPILER
           # Now generate the symbol file.  # -------------------
           eval "$lt_cv_global_symbol_to_cdecl"' < "$nlist" >> conftest.$ac_ext'  AC_DEFUN([_LT_AC_SYS_COMPILER],
   [AC_REQUIRE([AC_PROG_CC])dnl
   
           cat <<EOF >> conftest.$ac_ext  # If no C compiler was specified, use CC.
 #if defined (__STDC__) && __STDC__  LTCC=${LTCC-"$CC"}
 # define lt_ptr void *  
 #else  
 # define lt_ptr char *  
 # define const  
 #endif  
   
 /* The mapping between symbol names and symbols. */  # Allow CC to be a program name with arguments.
 const struct {  compiler=$CC
   const char *name;  ])# _LT_AC_SYS_COMPILER
   lt_ptr address;  
 }  
 lt_preloaded_symbols[[]] =  
 {  
 EOF  
           sed "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr) \&\2},/" < "$nlist" >> conftest.$ac_ext  
           cat <<\EOF >> conftest.$ac_ext  
   {0, (lt_ptr) 0}  
 };  
   
 #ifdef __cplusplus  
 }  
 #endif  
 EOF  
           # Now try linking the two files.  
           mv conftest.$ac_objext conftstm.$ac_objext  
           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  
           fi  
           LIBS="$save_LIBS"  
           CFLAGS="$save_CFLAGS"  
         else  
           echo "cannot find nm_test_func in $nlist" >&AC_FD_CC  
         fi  
       else  
         echo "cannot find nm_test_var in $nlist" >&AC_FD_CC  
       fi  
     else  
       echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AC_FD_CC  
     fi  
   else  
     echo "$progname: failed program was:" >&AC_FD_CC  
     cat conftest.$ac_ext >&5  
   fi  
   rm -f conftest* conftst*  
   
   # Do not use the global_symbol_pipe unless it works.  # _LT_CC_BASENAME(CC)
   if test "$pipe_works" = yes; then  # -------------------
     break  # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
   else  AC_DEFUN([_LT_CC_BASENAME],
     lt_cv_sys_global_symbol_pipe=  [for cc_temp in $1""; do
   fi    case $cc_temp in
       compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
       distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
       \-*) ;;
       *) break;;
     esac
 done  done
   cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
 ])  ])
 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"  
 fi  
 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)  
 fi  
 ]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE  
   
 # _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR  
 # ---------------------------------  # _LT_COMPILER_BOILERPLATE
 AC_DEFUN([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],  # ------------------------
 [# Find the correct PATH separator.  Usually this is `:', but  # Check for compiler boilerplate output or warnings with
 # DJGPP uses `;' like DOS.  # the simple compiler test code.
 if test "X${PATH_SEPARATOR+set}" != Xset; then  AC_DEFUN([_LT_COMPILER_BOILERPLATE],
   UNAME=${UNAME-`uname 2>/dev/null`}  [ac_outfile=conftest.$ac_objext
   case X$UNAME in  printf "$lt_simple_compile_test_code" >conftest.$ac_ext
     *-DOS) lt_cv_sys_path_separator=';' ;;  eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d' >conftest.err
     *)     lt_cv_sys_path_separator=':' ;;  _lt_compiler_boilerplate=`cat conftest.err`
   esac  $rm conftest*
   PATH_SEPARATOR=$lt_cv_sys_path_separator  ])# _LT_COMPILER_BOILERPLATE
 fi  
 ])# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR  
   # _LT_LINKER_BOILERPLATE
   # ----------------------
   # Check for linker boilerplate output or warnings with
   # the simple link test code.
   AC_DEFUN([_LT_LINKER_BOILERPLATE],
   [ac_outfile=conftest.$ac_objext
   printf "$lt_simple_link_test_code" >conftest.$ac_ext
   eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d' >conftest.err
   _lt_linker_boilerplate=`cat conftest.err`
   $rm conftest*
   ])# _LT_LINKER_BOILERPLATE
   
   
   # _LT_AC_SYS_LIBPATH_AIX
   # ----------------------
   # Links a minimal program and checks the executable
   # for the system default hardcoded library path. In most cases,
   # this is /usr/lib:/lib, but when the MPI compilers are used
   # the location of the communication and MPI libs are included too.
   # If we don't find anything, use the default library path according
   # to the aix ld manual.
   AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],
   [AC_LINK_IFELSE(AC_LANG_PROGRAM,[
   aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
   }'`
   # Check for a 64-bit object if we didn't find anything.
   if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
   }'`; fi],[])
   if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
   ])# _LT_AC_SYS_LIBPATH_AIX
   
   
   # _LT_AC_SHELL_INIT(ARG)
   # ----------------------
   AC_DEFUN([_LT_AC_SHELL_INIT],
   [ifdef([AC_DIVERSION_NOTICE],
                [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
            [AC_DIVERT_PUSH(NOTICE)])
   $1
   AC_DIVERT_POP
   ])# _LT_AC_SHELL_INIT
   
   
 # _LT_AC_PROG_ECHO_BACKSLASH  # _LT_AC_PROG_ECHO_BACKSLASH
 # --------------------------  # --------------------------
 # Add some code to the start of the generated configure script which  # Add some code to the start of the generated configure script which
 # will find an echo command which doesn't interpret backslashes.  # will find an echo command which doesn't interpret backslashes.
 AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],  AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],
 [ifdef([AC_DIVERSION_NOTICE], [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],  [_LT_AC_SHELL_INIT([
                               [AC_DIVERT_PUSH(NOTICE)])  
 _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR  
   
 # Check that we are running under the correct shell.  # Check that we are running under the correct shell.
 SHELL=${CONFIG_SHELL-/bin/sh}  SHELL=${CONFIG_SHELL-/bin/sh}
   
Line 522  if test "X[$]1" = X--no-reexec; then Line 811  if test "X[$]1" = X--no-reexec; then
 elif test "X[$]1" = X--fallback-echo; then  elif test "X[$]1" = X--fallback-echo; then
   # Avoid inline document here, it may be left over    # Avoid inline document here, it may be left over
   :    :
 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then  elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
   # Yippee, $echo works!    # Yippee, $echo works!
   :    :
 else  else
Line 534  if test "X[$]1" = X--fallback-echo; then Line 823  if test "X[$]1" = X--fallback-echo; then
   # used as fallback echo    # used as fallback echo
   shift    shift
   cat <<EOF    cat <<EOF
 $*  [$]*
 EOF  EOF
   exit 0    exit 0
 fi  fi
   
 # The HP-UX ksh and POSIX shell print the target directory to stdout  # The HP-UX ksh and POSIX shell print the target directory to stdout
 # if CDPATH is set.  # if CDPATH is set.
 if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi  (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
   
 if test -z "$ECHO"; then  if test -z "$ECHO"; then
 if test "X${echo_test_string+set}" != Xset; then  if test "X${echo_test_string+set}" != Xset; then
 # find a string as large as possible, as long as the shell can cope with it  # find a string as large as possible, as long as the shell can cope with it
   for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do    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, ...      # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
     if (echo_test_string="`eval $cmd`") 2>/dev/null &&      if (echo_test_string=`eval $cmd`) 2>/dev/null &&
        echo_test_string="`eval $cmd`" &&         echo_test_string=`eval $cmd` &&
        (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null         (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
     then      then
       break        break
Line 568  else Line 857  else
   #    #
   # So, first we look for a working echo in the user's PATH.    # So, first we look for a working echo in the user's PATH.
   
   IFS="${IFS=   }"; save_ifs="$IFS"; IFS=$PATH_SEPARATOR    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for dir in $PATH /usr/ucb; do    for dir in $PATH /usr/ucb; do
       IFS="$lt_save_ifs"
     if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&      if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
        test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&         test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
        echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&         echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
Line 578  else Line 868  else
       break        break
     fi      fi
   done    done
   IFS="$save_ifs"    IFS="$lt_save_ifs"
   
   if test "X$echo" = Xecho; then    if test "X$echo" = Xecho; then
     # We didn't find a better echo, so look for alternatives.      # We didn't find a better echo, so look for alternatives.
Line 651  if test "X$ECHO" = "X$CONFIG_SHELL [$]0 Line 941  if test "X$ECHO" = "X$CONFIG_SHELL [$]0
 fi  fi
   
 AC_SUBST(ECHO)  AC_SUBST(ECHO)
 AC_DIVERT_POP  ])])# _LT_AC_PROG_ECHO_BACKSLASH
 ])# _LT_AC_PROG_ECHO_BACKSLASH  
   
   # _LT_AC_LOCK
   # -----------
   AC_DEFUN([_LT_AC_LOCK],
   [AC_ARG_ENABLE([libtool-lock],
       [AC_HELP_STRING([--disable-libtool-lock],
           [avoid locking (might break parallel builds)])])
   test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
   
   # Some flags need to be propagated to the compiler or linker for good
   # libtool support.
   case $host in
   ia64-*-hpux*)
     # Find out which ABI we are using.
     echo 'int i;' > conftest.$ac_ext
     if AC_TRY_EVAL(ac_compile); then
       case `/usr/bin/file conftest.$ac_objext` in
       *ELF-32*)
         HPUX_IA64_MODE="32"
         ;;
       *ELF-64*)
         HPUX_IA64_MODE="64"
         ;;
       esac
     fi
     rm -rf conftest*
     ;;
   *-*-irix6*)
     # Find out which ABI we are using.
     echo '[#]line __oline__ "configure"' > conftest.$ac_ext
     if AC_TRY_EVAL(ac_compile); then
      if test "$lt_cv_prog_gnu_ld" = yes; then
       case `/usr/bin/file conftest.$ac_objext` in
       *32-bit*)
         LD="${LD-ld} -melf32bsmip"
         ;;
       *N32*)
         LD="${LD-ld} -melf32bmipn32"
         ;;
       *64-bit*)
         LD="${LD-ld} -melf64bmip"
         ;;
       esac
      else
       case `/usr/bin/file conftest.$ac_objext` in
       *32-bit*)
         LD="${LD-ld} -32"
         ;;
       *N32*)
         LD="${LD-ld} -n32"
         ;;
       *64-bit*)
         LD="${LD-ld} -64"
         ;;
       esac
      fi
     fi
     rm -rf conftest*
     ;;
   
   x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
     # Find out which ABI we are using.
     echo 'int i;' > conftest.$ac_ext
     if AC_TRY_EVAL(ac_compile); then
       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
     fi
     rm -rf conftest*
     ;;
   
   *-*-sco3.2v5*)
     # On SCO OpenServer 5, we need -belf to get full-featured binaries.
     SAVE_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS -belf"
     AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
       [AC_LANG_PUSH(C)
        AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
        AC_LANG_POP])
     if test x"$lt_cv_cc_needs_belf" != x"yes"; then
       # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
       CFLAGS="$SAVE_CFLAGS"
     fi
     ;;
   AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
   [*-*-cygwin* | *-*-mingw* | *-*-pw32*)
     AC_CHECK_TOOL(DLLTOOL, dlltool, false)
     AC_CHECK_TOOL(AS, as, false)
     AC_CHECK_TOOL(OBJDUMP, objdump, false)
     ;;
     ])
   esac
   
   need_locks="$enable_libtool_lock"
   
   ])# _LT_AC_LOCK
   
   
   # 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}\{0,1\} :&$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 other than the usual output.
        $echo "X$_lt_compiler_boilerplate" | $Xsed >conftest.exp
        $SED '/^$/d' conftest.err >conftest.er2
        if test ! -s conftest.err || diff conftest.exp conftest.er2 >/dev/null; then
          $2=yes
        fi
      fi
      $rm conftest*
   ])
   
   if test x"[$]$2" = xyes; then
       ifelse([$5], , :, [$5])
   else
       ifelse([$6], , :, [$6])
   fi
   ])# AC_LIBTOOL_COMPILER_OPTION
   
   
   # AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
   #                          [ACTION-SUCCESS], [ACTION-FAILURE])
   # ------------------------------------------------------------
   # Check whether the given compiler option works
   AC_DEFUN([AC_LIBTOOL_LINKER_OPTION],
   [AC_CACHE_CHECK([$1], [$2],
     [$2=no
      save_LDFLAGS="$LDFLAGS"
      LDFLAGS="$LDFLAGS $3"
      printf "$lt_simple_link_test_code" > conftest.$ac_ext
      if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
        # The linker 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
          $echo "X$_lt_linker_boilerplate" | $Xsed > conftest.exp
          $SED '/^$/d' conftest.err >conftest.er2
          if diff conftest.exp conftest.er2 >/dev/null; then
            $2=yes
          fi
        else
          $2=yes
        fi
      fi
      $rm conftest*
      LDFLAGS="$save_LDFLAGS"
   ])
   
   if test x"[$]$2" = xyes; then
       ifelse([$4], , :, [$4])
   else
       ifelse([$5], , :, [$5])
   fi
   ])# 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
     teststring="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*)
       # 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*)
       # 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;
       ;;
   
     netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
       # This has been around since 386BSD, at least.  Likely further.
       if test -x /sbin/sysctl; then
         lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
       elif test -x /usr/sbin/sysctl; then
         lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
       else
         lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
       fi
       # And add a safety zone
       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
       ;;
     osf*)
       # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
       # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
       # nice to cause kernel panics so lets avoid the loop below.
       # First set a reasonable default.
       lt_cv_sys_max_cmd_len=16384
       #
       if test -x /sbin/sysconfig; then
         case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
           *1*) lt_cv_sys_max_cmd_len=-1 ;;
         esac
       fi
       ;;
     *)
       # 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
       # we can't tell.
       SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
       while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \
                  = "XX$teststring") >/dev/null 2>&1 &&
               new_result=`expr "X$teststring" : ".*" 2>&1` &&
               lt_cv_sys_max_cmd_len=$new_result &&
               test $i != 17 # 1/2 MB should be enough
       do
         i=`expr $i + 1`
         teststring=$teststring$teststring
       done
       teststring=
       # 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)
   fi
   ])# AC_LIBTOOL_SYS_MAX_CMD_LEN
   
   
   # _LT_AC_CHECK_DLFCN
   # --------------------
   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,  # _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
 #                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)  #                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
 # ------------------------------------------------------------------  # ------------------------------------------------------------------
 AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],  AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
 [if test "$cross_compiling" = yes; then :  [AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
   if test "$cross_compiling" = yes; then :
   [$4]    [$4]
 else  else
   AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl  
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2    lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown    lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF    cat > conftest.$ac_ext <<EOF
Line 727  int main () Line 1332  int main ()
 }]  }]
 EOF  EOF
   if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then    if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
     (./conftest; exit; ) 2>/dev/null      (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
     lt_status=$?      lt_status=$?
     case x$lt_status in      case x$lt_status in
       x$lt_dlno_uscore) $1 ;;        x$lt_dlno_uscore) $1 ;;
Line 742  fi Line 1347  fi
 rm -fr conftest*  rm -fr conftest*
 ])# _LT_AC_TRY_DLOPEN_SELF  ])# _LT_AC_TRY_DLOPEN_SELF
   
   
 # AC_LIBTOOL_DLOPEN_SELF  # AC_LIBTOOL_DLOPEN_SELF
 # -------------------  # -------------------
 AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],  AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
 [if test "x$enable_dlopen" != xyes; then  [AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
   if test "x$enable_dlopen" != xyes; then
   enable_dlopen=unknown    enable_dlopen=unknown
   enable_dlopen_self=unknown    enable_dlopen_self=unknown
   enable_dlopen_self_static=unknown    enable_dlopen_self_static=unknown
Line 760  else Line 1367  else
     lt_cv_dlopen_self=yes      lt_cv_dlopen_self=yes
     ;;      ;;
   
   cygwin* | mingw* | pw32*)    mingw* | pw32*)
     lt_cv_dlopen="LoadLibrary"      lt_cv_dlopen="LoadLibrary"
     lt_cv_dlopen_libs=      lt_cv_dlopen_libs=
    ;;     ;;
   
     cygwin*)
       lt_cv_dlopen="dlopen"
       lt_cv_dlopen_libs=
      ;;
   
     darwin*)
     # if libdl is installed we need to link against it
       AC_CHECK_LIB([dl], [dlopen],
                   [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
       lt_cv_dlopen="dyld"
       lt_cv_dlopen_libs=
       lt_cv_dlopen_self=yes
       ])
      ;;
   
   *)    *)
     AC_CHECK_FUNC([dllload],      AC_CHECK_FUNC([shl_load],
         [lt_cv_dlopen="dllload"],            [lt_cv_dlopen="shl_load"],
     [AC_CHECK_FUNC([shl_load],  
           [lt_cv_dlopen="shl_load"],  
       [AC_CHECK_LIB([dld], [shl_load],        [AC_CHECK_LIB([dld], [shl_load],
             [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],              [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],
         [AC_CHECK_FUNC([dlopen],          [AC_CHECK_FUNC([dlopen],
               [lt_cv_dlopen="dlopen"],                [lt_cv_dlopen="dlopen"],
           [AC_CHECK_LIB([dl], [dlopen],            [AC_CHECK_LIB([dl], [dlopen],
                 [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],                  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
             [AC_CHECK_LIB([svld], [dlopen],              [AC_CHECK_LIB([svld], [dlopen],
                   [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],                    [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
               [AC_CHECK_LIB([dld], [dld_link],                [AC_CHECK_LIB([dld], [dld_link],
                     [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])                      [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])
               ])                ])
             ])              ])
           ])            ])
         ])          ])
       ])        ])
     ])  
     ;;      ;;
   esac    esac
   
Line 798  else Line 1417  else
   case $lt_cv_dlopen in    case $lt_cv_dlopen in
   dlopen)    dlopen)
     save_CPPFLAGS="$CPPFLAGS"      save_CPPFLAGS="$CPPFLAGS"
     AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl  
     test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"      test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
   
     save_LDFLAGS="$LDFLAGS"      save_LDFLAGS="$LDFLAGS"
Line 842  else Line 1460  else
 fi  fi
 ])# AC_LIBTOOL_DLOPEN_SELF  ])# AC_LIBTOOL_DLOPEN_SELF
   
 AC_DEFUN([_LT_AC_LTCONFIG_HACK],  
 [AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])dnl  
 # Sed substitution that helps us do robust quoting.  It backslashifies  
 # metacharacters that are still active within double-quoted strings.  
 Xsed='sed -e s/^X//'  
 sed_quote_subst='s/\([[\\"\\`$\\\\]]\)/\\\1/g'  
   
 # Same as above, but do not quote variable references.  
 double_quote_subst='s/\([[\\"\\`\\\\]]\)/\\\1/g'  
   
 # Sed substitution to delay expansion of an escaped shell variable in a  
 # double_quote_subst'ed string.  
 delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'  
   
 # Constants:  
 rm="rm -f"  
   
 # Global variables:  
 default_ofile=libtool  
 can_build_shared=yes  
   
 # All known linkers require a `.a' archive for static linking (except M$VC,  
 # which needs '.lib').  
 libext=a  
 ltmain="$ac_aux_dir/ltmain.sh"  
 ofile="$default_ofile"  
 with_gnu_ld="$lt_cv_prog_gnu_ld"  
 need_locks="$enable_libtool_lock"  
   
 old_CC="$CC"  # AC_LIBTOOL_PROG_CC_C_O([TAGNAME])
 old_CFLAGS="$CFLAGS"  # ---------------------------------
   # Check to see if options -c and -o are simultaneously supported by compiler
 # Set sane defaults for various variables  AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],
 test -z "$AR" && AR=ar  [AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
 test -z "$AR_FLAGS" && AR_FLAGS=cru  AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
 test -z "$AS" && AS=as    [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
 test -z "$CC" && CC=cc    [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
 test -z "$DLLTOOL" && DLLTOOL=dlltool     $rm -r conftest 2>/dev/null
 test -z "$LD" && LD=ld     mkdir conftest
 test -z "$LN_S" && LN_S="ln -s"     cd conftest
 test -z "$MAGIC_CMD" && MAGIC_CMD=file     mkdir out
 test -z "$NM" && NM=nm     printf "$lt_simple_compile_test_code" > conftest.$ac_ext
 test -z "$OBJDUMP" && OBJDUMP=objdump  
 test -z "$RANLIB" && RANLIB=:     lt_compiler_flag="-o out/conftest2.$ac_objext"
 test -z "$STRIP" && STRIP=:     # Insert the option either (1) after the last *FLAGS variable, or
 test -z "$ac_objext" && ac_objext=o     # (2) before a word containing "conftest.", or (3) at the end.
      # Note that $ac_compile itself does not contain backslashes and begins
 if test x"$host" != x"$build"; then     # with a dollar sign (not a hyphen), so the echo should work correctly.
   ac_tool_prefix=${host_alias}-     lt_compile=`echo "$ac_compile" | $SED \
 else     -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   ac_tool_prefix=     -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
 fi     -e 's:$: $lt_compiler_flag:'`
      (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
 # Transform linux* to *-*-linux-gnu*, to support old configure scripts.     (eval "$lt_compile" 2>out/conftest.err)
 case $host_os in     ac_status=$?
 linux-gnu*) ;;     cat out/conftest.err >&AS_MESSAGE_LOG_FD
 linux*) host=`echo $host | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'`     echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
 esac     if (exit $ac_status) && test -s out/conftest2.$ac_objext
      then
 case $host_os in       # The compiler can only warn and ignore the option if not recognized
 aix3*)       # So say no if there are warnings
   # AIX sometimes has problems with the GCC collect2 program.  For some       $echo "X$_lt_compiler_boilerplate" | $Xsed > out/conftest.exp
   # reason, if we set the COLLECT_NAMES environment variable, the problems       $SED '/^$/d' out/conftest.err >out/conftest.er2
   # vanish in a puff of smoke.       if test ! -s out/conftest.err || diff out/conftest.exp out/conftest.er2 >/dev/null; then
   if test "X${COLLECT_NAMES+set}" != Xset; then         _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
     COLLECT_NAMES=       fi
     export COLLECT_NAMES     fi
   fi     chmod u+w . 2>&AS_MESSAGE_LOG_FD
   ;;     $rm conftest*
 esac     # SGI C++ compiler will create directory out/ii_files/ for
      # template instantiation
 # Determine commands to create old-style static archives.     test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
 old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'     $rm out/* && rmdir out
 old_postinstall_cmds='chmod 644 $oldlib'     cd ..
 old_postuninstall_cmds=     rmdir conftest
      $rm conftest*
 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"  
 fi  
   
 # Allow CC to be a program name with arguments.  
 set dummy $CC  
 compiler="[$]2"  
   
 AC_MSG_CHECKING([for objdir])  
 rm -f .libs 2>/dev/null  
 mkdir .libs 2>/dev/null  
 if test -d .libs; then  
   objdir=.libs  
 else  
   # MS-DOS does not allow filenames that begin with a dot.  
   objdir=_libs  
 fi  
 rmdir .libs 2>/dev/null  
 AC_MSG_RESULT($objdir)  
   
   
 AC_ARG_WITH(pic,  
 [  --with-pic              try to use only PIC/non-PIC objects [default=use both]],  
 pic_mode="$withval", pic_mode=default)  
 test -z "$pic_mode" && pic_mode=default  
   
 # We assume here that the value for lt_cv_prog_cc_pic will not be cached  
 # in isolation, and that seeing it set (from the cache) indicates that  
 # the associated values are set (in the cache) correctly too.  
 AC_MSG_CHECKING([for $compiler option to produce PIC])  
 AC_CACHE_VAL(lt_cv_prog_cc_pic,  
 [ lt_cv_prog_cc_pic=  
   lt_cv_prog_cc_shlib=  
   lt_cv_prog_cc_wl=  
   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  
     lt_cv_prog_cc_wl='-Wl,'  
     lt_cv_prog_cc_static='-static'  
   
     case $host_os in  
     aix*)  
       # Below there is a dirty hack to force normal static linking with -ldl  
       # The problem is because libdl dynamically linked with both libc and  
       # libC (AIX C++ library), which obviously doesn't included in libraries  
       # list by gcc. This cause undefined symbols with -static flags.  
       # This hack allows C programs to be linked with "-static -ldl", but  
       # not sure about C++ programs.  
       lt_cv_prog_cc_static="$lt_cv_prog_cc_static ${lt_cv_prog_cc_wl}-lC"  
       ;;  
     amigaos*)  
       # FIXME: we need at least 68020 code to build shared libraries, but  
       # adding the `-m68020' flag to GCC prevents building anything better,  
       # like `-m68040'.  
       lt_cv_prog_cc_pic='-m68020 -resident32 -malways-restore-a4'  
       ;;  
     beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)  
       # PIC is the default for these OSes.  
       ;;  
     darwin* | rhapsody*)  
       # PIC is the default on this platform  
       # Common symbols not allowed in MH_DYLIB files  
       lt_cv_prog_cc_pic='-fno-common'  
       ;;  
     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  
       fi  
       ;;  
     *)  
       lt_cv_prog_cc_pic='-fPIC'  
       ;;  
     esac  
   else  
     # PORTME Check for PIC flags for the system compiler.  
     case $host_os in  
     aix3* | aix4* | aix5*)  
       lt_cv_prog_cc_wl='-Wl,'  
       # All AIX code is PIC.  
       if test "$host_cpu" = ia64; then  
         # AIX 5 now supports IA64 processor  
         lt_cv_prog_cc_static='-Bstatic'  
       else  
         lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'  
       fi  
       ;;  
   
     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'  
       ;;  
   
     irix5* | irix6* | nonstopux*)  
       lt_cv_prog_cc_wl='-Wl,'  
       lt_cv_prog_cc_static='-non_shared'  
       # PIC (with -KPIC) is the default.  
       ;;  
   
     cygwin* | mingw* | pw32* | os2*)  
       # This hack is so that the source file can tell whether it is being  
       # built for inclusion in a dll (and should export symbols for example).  
       lt_cv_prog_cc_pic='-DDLL_EXPORT'  
       ;;  
   
     newsos6)  
       lt_cv_prog_cc_pic='-KPIC'  
       lt_cv_prog_cc_static='-Bstatic'  
       ;;  
       
     openedition)  
       # XPLINK code is PIC by default  
       ;;  
   
     osf3* | osf4* | osf5*)  
       # All OSF/1 code is PIC.  
       lt_cv_prog_cc_wl='-Wl,'  
       lt_cv_prog_cc_static='-non_shared'  
       ;;  
   
     sco3.2v5*)  
       lt_cv_prog_cc_pic='-Kpic'  
       lt_cv_prog_cc_static='-dn'  
       lt_cv_prog_cc_shlib='-belf'  
       ;;  
   
     solaris*)  
       lt_cv_prog_cc_pic='-KPIC'  
       lt_cv_prog_cc_static='-Bstatic'  
       lt_cv_prog_cc_wl='-Wl,'  
       ;;  
   
     sunos4*)  
       lt_cv_prog_cc_pic='-PIC'  
       lt_cv_prog_cc_static='-Bstatic'  
       lt_cv_prog_cc_wl='-Qoption ld '  
       ;;  
   
     sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)  
       lt_cv_prog_cc_pic='-KPIC'  
       lt_cv_prog_cc_static='-Bstatic'  
       lt_cv_prog_cc_wl='-Wl,'  
       ;;  
   
     uts4*)  
       lt_cv_prog_cc_pic='-pic'  
       lt_cv_prog_cc_static='-Bstatic'  
       ;;  
   
     sysv4*MP*)  
       if test -d /usr/nec ;then  
         lt_cv_prog_cc_pic='-Kconform_pic'  
         lt_cv_prog_cc_static='-Bstatic'  
       fi  
       ;;  
   
     *)  
       lt_cv_prog_cc_can_build_shared=no  
       ;;  
     esac  
   fi  
 ])  ])
 if test -z "$lt_cv_prog_cc_pic"; then  ])# AC_LIBTOOL_PROG_CC_C_O
   AC_MSG_RESULT([none])  
 else  
   AC_MSG_RESULT([$lt_cv_prog_cc_pic])  
   
   # Check to make sure the pic_flag actually works.  
   AC_MSG_CHECKING([if $compiler PIC flag $lt_cv_prog_cc_pic works])  
   AC_CACHE_VAL(lt_cv_prog_cc_pic_works, [dnl  
     save_CFLAGS="$CFLAGS"  
     CFLAGS="$CFLAGS $lt_cv_prog_cc_pic -DPIC"  
     AC_TRY_COMPILE([], [], [dnl  
       case $host_os in  
       hpux9* | hpux10* | hpux11*)  
         # On HP-UX, both CC and GCC only warn that PIC is supported... then  
         # they create non-PIC objects.  So, if there were any warnings, we  
         # assume that PIC is not supported.  
         if test -s conftest.err; then  
           lt_cv_prog_cc_pic_works=no  
         else  
           lt_cv_prog_cc_pic_works=yes  
         fi  
         ;;  
       *)  
         lt_cv_prog_cc_pic_works=yes  
         ;;  
       esac  
     ], [dnl  
       lt_cv_prog_cc_pic_works=no  
     ])  
     CFLAGS="$save_CFLAGS"  
   ])  
   
   if test "X$lt_cv_prog_cc_pic_works" = Xno; then  
     lt_cv_prog_cc_pic=  
     lt_cv_prog_cc_can_build_shared=no  
   else  
     lt_cv_prog_cc_pic=" $lt_cv_prog_cc_pic"  
   fi  
   
   AC_MSG_RESULT([$lt_cv_prog_cc_pic_works])  
 fi  
   
 # Check for any special shared library compilation flags.  
 if test -n "$lt_cv_prog_cc_shlib"; then  
   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  
    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  
   fi  
 fi  
   
 AC_MSG_CHECKING([if $compiler static flag $lt_cv_prog_cc_static works])  
 AC_CACHE_VAL([lt_cv_prog_cc_static_works], [dnl  
   lt_cv_prog_cc_static_works=no  
   save_LDFLAGS="$LDFLAGS"  
   LDFLAGS="$LDFLAGS $lt_cv_prog_cc_static"  
   AC_TRY_LINK([], [], [lt_cv_prog_cc_static_works=yes])  
   LDFLAGS="$save_LDFLAGS"  
 ])  
   
 # Belt *and* braces to stop my trousers falling down:  
 test "X$lt_cv_prog_cc_static_works" = Xno && lt_cv_prog_cc_static=  
 AC_MSG_RESULT([$lt_cv_prog_cc_static_works])  
   
 pic_flag="$lt_cv_prog_cc_pic"  
 special_shlib_compile_flags="$lt_cv_prog_cc_shlib"  
 wl="$lt_cv_prog_cc_wl"  
 link_static_flag="$lt_cv_prog_cc_static"  
 no_builtin_flag="$lt_cv_prog_cc_no_builtin"  
 can_build_shared="$lt_cv_prog_cc_can_build_shared"  
   
   
 # Check to see if options -o and -c are simultaneously supported by compiler  
 AC_MSG_CHECKING([if $compiler supports -c -o file.$ac_objext])  
 AC_CACHE_VAL([lt_cv_compiler_c_o], [  
 $rm -r conftest 2>/dev/null  
 mkdir conftest  
 cd conftest  
 echo "int some_variable = 0;" > conftest.$ac_ext  
 mkdir out  
 # According to Tom Tromey, Ian Lance Taylor reported there are C compilers  
 # that will create temporary files in the current directory regardless of  
 # the output directory.  Thus, making CWD read-only will cause this test  
 # to fail, enabling locking or at least warning the user not to do parallel  
 # builds.  
 chmod -w .  
 save_CFLAGS="$CFLAGS"  
 CFLAGS="$CFLAGS -o out/conftest2.$ac_objext"  
 compiler_c_o=no  
 if { (eval echo configure:__oline__: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then  
   # The compiler can only warn and ignore the option if not recognized  
   # So say no if there are warnings  
   if test -s out/conftest.err; then  
     lt_cv_compiler_c_o=no  
   else  
     lt_cv_compiler_c_o=yes  
   fi  
 else  
   # Append any errors to the config.log.  
   cat out/conftest.err 1>&AC_FD_CC  
   lt_cv_compiler_c_o=no  
 fi  
 CFLAGS="$save_CFLAGS"  
 chmod u+w .  
 $rm conftest* out/*  
 rmdir out  
 cd ..  
 rmdir conftest  
 $rm -r conftest 2>/dev/null  
 ])  
 compiler_c_o=$lt_cv_compiler_c_o  
 AC_MSG_RESULT([$compiler_c_o])  
   
 if test x"$compiler_c_o" = x"yes"; then  
   # 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  
     fi  
   ])  
   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  
 fi  
   
   # AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])
   # -----------------------------------------
 # Check to see if we can do hard links to lock some files if needed  # 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"  hard_links="nottested"
 if test "$compiler_c_o" = no && test "$need_locks" != no; then  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    # do not overwrite the value of need_locks provided by the user
   AC_MSG_CHECKING([if we can lock with hard links])    AC_MSG_CHECKING([if we can lock with hard links])
   hard_links=yes    hard_links=yes
Line 1250  if test "$compiler_c_o" = no && test "$n Line 1530  if test "$compiler_c_o" = no && test "$n
   ln conftest.a conftest.b 2>/dev/null && hard_links=no    ln conftest.a conftest.b 2>/dev/null && hard_links=no
   AC_MSG_RESULT([$hard_links])    AC_MSG_RESULT([$hard_links])
   if test "$hard_links" = no; then    if test "$hard_links" = no; then
     AC_MSG_WARN([\`$CC' does not support \`-c -o', so \`make -j' may be unsafe])      AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
     need_locks=warn      need_locks=warn
   fi    fi
 else  else
   need_locks=no    need_locks=no
 fi  fi
   ])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS
   
 if test "$GCC" = yes; then  
   # 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  
     fi  
   ])  
   CFLAGS="$save_CFLAGS"  
   AC_MSG_RESULT([$compiler_rtti_exceptions])  
   
   if test "$compiler_rtti_exceptions" = "yes"; then  
     no_builtin_flag=' -fno-builtin -fno-rtti -fno-exceptions'  
   else  
     no_builtin_flag=' -fno-builtin'  
   fi  
 fi  
   
 # See if the linker supports building shared libraries.  
 AC_MSG_CHECKING([whether the linker ($LD) supports shared libraries])  
   
 allow_undefined_flag=  
 no_undefined_flag=  
 need_lib_prefix=unknown  
 need_version=unknown  
 # when you set need_version to no, make sure it does not cause -set_version  
 # flags to be left without arguments  
 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  
   fi  
   ;;  
 openbsd*)  
   with_gnu_ld=no  
   ;;  
 esac  
   
 ld_shlibs=yes  
 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.  
   case $host_os in  
   aix3* | aix4* | aix5*)  
     # On AIX, the GNU linker is very broken  
     # Note:Check GNU linker on AIX 5-IA64 when/if it becomes available.  
     ld_shlibs=no  
     cat <<EOF 1>&2  
   
 *** Warning: the GNU linker, at least up to release 2.9.1, is reported  
 *** to be unable to reliably create shared libraries on AIX.  
 *** Therefore, libtool is disabling shared libraries support.  If you  
 *** really care for shared libraries, you may want to modify your PATH  
 *** so that a non-GNU linker is found, and then restart.  
   
 EOF  
     ;;  
   
   amigaos*)  
     archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'  
     hardcode_libdir_flag_spec='-L$libdir'  
     hardcode_minus_L=yes  
   
     # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports  
     # 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 use  
     # them.  
     ld_shlibs=no  
     ;;  
   
   beos*)  
     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  
     fi  
     ;;  
   
   cygwin* | mingw* | pw32*)  
     # hardcode_libdir_flag_spec is actually meaningless, as there is  
     # no search path for DLLs.  
     hardcode_libdir_flag_spec='-L$libdir'  
     allow_undefined_flag=unsupported  
     always_export_symbols=yes  
   
     extract_expsyms_cmds='test -f $output_objdir/impgen.c || \  
       sed -e "/^# \/\* impgen\.c starts here \*\//,/^# \/\* impgen.c ends here \*\// { s/^# //;s/^# *$//; p; }" -e d < $''0 > $output_objdir/impgen.c~  
       test -f $output_objdir/impgen.exe || (cd $output_objdir && \  
       if test "x$HOST_CC" != "x" ; then $HOST_CC -o impgen impgen.c ; \  
       else $CC -o impgen impgen.c ; fi)~  
       $output_objdir/impgen $dir/$soroot > $output_objdir/$soname-def'  
   
     old_archive_from_expsyms_cmds='$DLLTOOL --as=$AS --dllname $soname --def $output_objdir/$soname-def --output-lib $output_objdir/$newlib'  
   
     # cygwin and mingw dlls have different entry points and sets of symbols  
     # to exclude.  
     # FIXME: what about values for MSVC?  
     dll_entry=__cygwin_dll_entry@12  
     dll_exclude_symbols=DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12~  
     case $host_os in  
     mingw*)  
       # mingw values  
       dll_entry=_DllMainCRTStartup@12  
       dll_exclude_symbols=DllMain@12,DllMainCRTStartup@12,DllEntryPoint@12~  
       ;;  
     esac  
   
     # mingw and cygwin differ, and it's simplest to just exclude the union  
     # 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=  
     fi  
   
     # Extract the symbol export list from an `--export-all' def file,  
     # then regenerate the def file from the symbol export list, so that  
     # the compiled dll only exports the symbol export list.  
     # Be careful not to strip the DATA tag left be newer dlltools.  
     export_symbols_cmds="$ltdll_cmds"'  
       $DLLTOOL --export-all --exclude-symbols '$dll_exclude_symbols' --output-def $output_objdir/$soname-def '$ltdll_obj'$libobjs $convenience~  
       sed -e "1,/EXPORTS/d" -e "s/ @ [[0-9]]*//" -e "s/ *;.*$//" < $output_objdir/$soname-def > $export_symbols'  
   
     # If the export-symbols file already is a .def file (1st line  
     # is EXPORTS), use it as is.  
     # If DATA tags from a recent dlltool are present, honour them!  
     archive_expsym_cmds='if test "x`sed 1q $export_symbols`" = xEXPORTS; then  
         cp $export_symbols $output_objdir/$soname-def;  
       else  
         echo EXPORTS > $output_objdir/$soname-def;  
         _lt_hint=1;  
         cat $export_symbols | while read symbol; do  
          set dummy \$symbol;  
          case \[$]# in  
            2) echo "   \[$]2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;  
            4) echo "   \[$]2 \[$]3 \[$]4 ; " >> $output_objdir/$soname-def; _lt_hint=`expr \$_lt_hint - 1`;;  
            *) echo "     \[$]2 @ \$_lt_hint \[$]3 ; " >> $output_objdir/$soname-def;;  
          esac;  
          _lt_hint=`expr 1 + \$_lt_hint`;  
         done;  
       fi~  
       '"$ltdll_cmds"'  
       $CC -Wl,--base-file,$output_objdir/$soname-base '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~  
       $DLLTOOL --as=$AS --dllname $soname --exclude-symbols '$dll_exclude_symbols' --def $output_objdir/$soname-def --base-file $output_objdir/$soname-base --output-exp $output_objdir/$soname-exp~  
       $CC -Wl,--base-file,$output_objdir/$soname-base $output_objdir/$soname-exp '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~  
       $DLLTOOL --as=$AS --dllname $soname --exclude-symbols '$dll_exclude_symbols' --def $output_objdir/$soname-def --base-file $output_objdir/$soname-base --output-exp $output_objdir/$soname-exp --output-lib $output_objdir/$libname.dll.a~  
       $CC $output_objdir/$soname-exp '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags'  
     ;;  
   
   netbsd*)  
     if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then  
       archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'  
       wlarc=  
     else  
       archive_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'  
       archive_expsym_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'  
     fi  
     ;;  
   
   solaris* | sysv5*)  
     if $LD -v 2>&1 | egrep 'BFD 2\.8' > /dev/null; then  
       ld_shlibs=no  
       cat <<EOF 1>&2  
   
 *** Warning: The releases 2.8.* of the GNU linker cannot reliably  # AC_LIBTOOL_OBJDIR
 *** create shared libraries on Solaris systems.  Therefore, libtool  # -----------------
 *** is disabling shared libraries support.  We urge you to upgrade GNU  AC_DEFUN([AC_LIBTOOL_OBJDIR],
 *** binutils to release 2.9.1 or newer.  Another option is to modify  [AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
 *** your PATH or compiler configuration so that the native linker is  [rm -f .libs 2>/dev/null
 *** used, and then restart.  mkdir .libs 2>/dev/null
   if test -d .libs; then
 EOF    lt_cv_objdir=.libs
     elif $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then  
       archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'  
       archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'  
     else  
       ld_shlibs=no  
     fi  
     ;;  
   
   sunos4*)  
     archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'  
     wlarc=  
     hardcode_direct=yes  
     hardcode_shlibpath_var=no  
     ;;  
   
   *)  
     if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then  
       archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'  
       archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'  
     else  
       ld_shlibs=no  
     fi  
     ;;  
   esac  
   
   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 $LD --help 2>&1 | egrep 'no-whole-archive' > /dev/null; then  
         whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'  
       else  
         whole_archive_flag_spec=  
       fi  
       ;;  
     esac  
   fi  
 else  else
   # PORTME fill in a description of your system's linker (not GNU ld)    # MS-DOS does not allow filenames that begin with a dot.
   case $host_os in    lt_cv_objdir=_libs
   aix3*)  
     allow_undefined_flag=unsupported  
     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  
     fi  
     ;;  
   
   aix4* | aix5*)  
     if test "$host_cpu" = ia64; then  
       # On IA64, the linker does run time linking by default, so we don't  
       # have to do anything special.  
       aix_use_runtimelinking=no  
       exp_sym_flag='-Bexport'  
       no_entry_flag=""  
     else  
       aix_use_runtimelinking=no  
   
       # Test if we are trying to use run time linking or normal  
       # 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  
           case $ld_flag in  
           *-brtl*)  
             aix_use_runtimelinking=yes  
             break  
           ;;  
           esac  
         done  
       esac  
   
       exp_sym_flag='-bexport'  
       no_entry_flag='-bnoentry'  
     fi  
   
     # 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.  
   
     hardcode_direct=yes  
     archive_cmds=''  
     hardcode_libdir_separator=':'  
     if test "$GCC" = yes; then  
       case $host_os in aix4.[[012]]|aix4.[[012]].*)  
         collect2name=`${CC} -print-prog-name=collect2`  
         if test -f "$collect2name" && \  
           strings "$collect2name" | grep resolve_lib_name >/dev/null  
         then  
           # We have reworked collect2  
           hardcode_direct=yes  
         else  
           # We have old collect2  
           hardcode_direct=unsupported  
           # It fails to find uninstalled libraries when the uninstalled  
           # path is not listed in the libpath.  Setting hardcode_minus_L  
           # to unsupported forces relinking  
           hardcode_minus_L=yes  
           hardcode_libdir_flag_spec='-L$libdir'  
           hardcode_libdir_separator=  
         fi  
       esac  
   
       shared_flag='-shared'  
     else  
       # not using gcc  
       if test "$host_cpu" = ia64; then  
         shared_flag='${wl}-G'  
       else  
         if test "$aix_use_runtimelinking" = yes; then  
           shared_flag='${wl}-G'  
         else  
           shared_flag='${wl}-bM:SRE'  
         fi  
       fi  
     fi  
   
     # It seems that -bexpall can do strange things, so it is better to  
     # generate a list of symbols to export.  
     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.  
       allow_undefined_flag='-berok'  
       hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:/usr/lib:/lib'  
       archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"  
     else  
       if test "$host_cpu" = ia64; then  
         hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'  
         allow_undefined_flag="-z nodefs"  
         archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"  
       else  
         hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'  
         # Warning - without using the other run time loading flags,  
         # -berok will link without error, but may produce a broken library.  
         allow_undefined_flag='${wl}-berok'  
         # This is a bit strange, but is similar to how AIX traditionally builds  
         # it's shared libraries.  
         archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $objdir/$libname$release.a $objdir/$soname'  
       fi  
     fi  
     ;;  
   
   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  
     # see comment about different semantics on the GNU ld section  
     ld_shlibs=no  
     ;;  
   
   cygwin* | mingw* | pw32*)  
     # When not using gcc, we currently assume that we are using  
     # Microsoft Visual C++.  
     # hardcode_libdir_flag_spec is actually meaningless, as there is  
     # no search path for DLLs.  
     hardcode_libdir_flag_spec=' '  
     allow_undefined_flag=unsupported  
     # Tell ltmain to make .lib files, not .a files.  
     libext=lib  
     # FIXME: Setting linknames here is a bad hack.  
     archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | sed -e '\''s/ -lc$//'\''` -link -dll~linknames='  
     # The linker will automatically build a .lib file if we build a DLL.  
     old_archive_from_new_cmds='true'  
     # FIXME: Should let the user specify the lib program.  
     old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs'  
     fix_srcfile_path='`cygpath -w "$srcfile"`'  
     ;;  
   
   darwin* | rhapsody*)  
     case "$host_os" in  
     rhapsody* | darwin1.[[012]])  
       allow_undefined_flag='-undefined suppress'  
       ;;  
     *) # Darwin 1.3 on  
       allow_undefined_flag='-flat_namespace -undefined suppress'  
       ;;  
     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  
     hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'  
     hardcode_libdir_separator=:  
     hardcode_direct=yes  
     hardcode_minus_L=yes # Not in the search PATH, but as the default  
                          # location of the library.  
     export_dynamic_flag_spec='${wl}-E'  
     ;;  
   
   irix5* | irix6* | nonstopux*)  
     if test "$GCC" = yes; then  
       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  
       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'  
     fi  
     hardcode_libdir_separator=:  
     link_all_deplibs=yes  
     ;;  
   
   netbsd*)  
     if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then  
       archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out  
     else  
       archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF  
     fi  
     hardcode_libdir_flag_spec='-R$libdir'  
     hardcode_direct=yes  
     hardcode_shlibpath_var=no  
     ;;  
   
   newsos6)  
     archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'  
     hardcode_direct=yes  
     hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'  
     hardcode_libdir_separator=:  
     hardcode_shlibpath_var=no  
     ;;  
   
   openbsd*)  
     hardcode_direct=yes  
     hardcode_shlibpath_var=no  
     if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then  
       archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'  
       hardcode_libdir_flag_spec='${wl}-rpath,$libdir'  
       export_dynamic_flag_spec='${wl}-E'  
     else  
       case "$host_os" in  
       openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)  
         archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  
         hardcode_libdir_flag_spec='-R$libdir'  
         ;;  
       *)  
         archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'  
         hardcode_libdir_flag_spec='${wl}-rpath,$libdir'  
         ;;  
       esac  
     fi  
     ;;  
   
   openedition*)  
     archive_cmds="\$CC -Wl,DLL \$libobjs \$deplibs \$compiler_flags -o \$lib &&  
         cp \$linknames \$output_objdir && linknames=''"  
     export_dynamic_flag_spec="-Wl,DLL"  
     ;;  
   
   os2*)  
     hardcode_libdir_flag_spec='-L$libdir'  
     hardcode_minus_L=yes  
     allow_undefined_flag=unsupported  
     archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'  
     old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'  
     ;;  
   
   osf3*)  
     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  
       allow_undefined_flag=' -expect_unresolved \*'  
       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'  
     fi  
     hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'  
     hardcode_libdir_separator=:  
     ;;  
   
   osf4* | osf5*)        # as osf3* with the addition of -msym flag  
     if test "$GCC" = yes; then  
       allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'  
       archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'  
       hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'  
     else  
       allow_undefined_flag=' -expect_unresolved \*'  
       archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'  
       archive_expsym_cmds='for i in `cat $export_symbols`; do printf "-exported_symbol " >> $lib.exp; echo "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~  
       $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp'  
   
       #Both c and cxx compiler support -rpath directly  
       hardcode_libdir_flag_spec='-rpath $libdir'  
     fi  
     hardcode_libdir_separator=:  
     ;;  
   
   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'  
     ;;  
   
   solaris*)  
     # gcc --version < 3.0 without binutils cannot create self contained  
     # 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  
     fi  
     # $CC -shared without GNU ld will not create a library from C++  
     # object files and a static libstdc++, better avoid it by now  
     archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'  
     archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~  
                 $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'  
     hardcode_libdir_flag_spec='-R$libdir'  
     hardcode_shlibpath_var=no  
     case $host_os in  
     solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;  
     *) # Supported since Solaris 2.6 (maybe 2.5.1?)  
       whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;  
     esac  
     link_all_deplibs=yes  
     ;;  
   
   sunos4*)  
     if test "x$host_vendor" = xsequent; then  
       # Use $CC to link under sequent, because it throws in some extra .o  
       # files that make .init and .fini sections work.  
       archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'  
     else  
       archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'  
     fi  
     hardcode_libdir_flag_spec='-L$libdir'  
     hardcode_direct=yes  
     hardcode_minus_L=yes  
     hardcode_shlibpath_var=no  
     ;;  
   
   sysv4)  
     case $host_vendor in  
       sni)  
         archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'  
         hardcode_direct=yes # is this really true???  
         ;;  
       siemens)  
         ## LD is ld it makes a PLAMLIB  
         ## CC just makes a GrossModule.  
         archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'  
         reload_cmds='$CC -r -o $output$reload_objs'  
         hardcode_direct=no  
         ;;  
       motorola)  
         archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'  
         hardcode_direct=no #Motorola manual says yes, but my tests say they lie  
         ;;  
     esac  
     runpath_var='LD_RUN_PATH'  
     hardcode_shlibpath_var=no  
     ;;  
   
   sysv4.3*)  
     archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'  
     hardcode_shlibpath_var=no  
     export_dynamic_flag_spec='-Bexport'  
     ;;  
   
   sysv5*)  
     no_undefined_flag=' -z text'  
     # $CC -shared without GNU ld will not create a library from C++  
     # object files and a static libstdc++, better avoid it by now  
     archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'  
     archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~  
                 $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'  
     hardcode_libdir_flag_spec=  
     hardcode_shlibpath_var=no  
     runpath_var='LD_RUN_PATH'  
     ;;  
   
   uts4*)  
     archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'  
     hardcode_libdir_flag_spec='-L$libdir'  
     hardcode_shlibpath_var=no  
     ;;  
   
   dgux*)  
     archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'  
     hardcode_libdir_flag_spec='-L$libdir'  
     hardcode_shlibpath_var=no  
     ;;  
   
   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  
       hardcode_runpath_var=yes  
       ld_shlibs=yes  
     fi  
     ;;  
   
   sysv4.2uw2*)  
     archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'  
     hardcode_direct=yes  
     hardcode_minus_L=no  
     hardcode_shlibpath_var=no  
     hardcode_runpath_var=yes  
     runpath_var=LD_RUN_PATH  
     ;;  
   
   sysv5uw7* | unixware7*)  
     no_undefined_flag='${wl}-z ${wl}text'  
     if test "$GCC" = yes; then  
       archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'  
     else  
       archive_cmds='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'  
     fi  
     runpath_var='LD_RUN_PATH'  
     hardcode_shlibpath_var=no  
     ;;  
   
   *)  
     ld_shlibs=no  
     ;;  
   esac  
 fi  fi
 AC_MSG_RESULT([$ld_shlibs])  rmdir .libs 2>/dev/null])
 test "$ld_shlibs" = no && can_build_shared=no  objdir=$lt_cv_objdir
   ])# AC_LIBTOOL_OBJDIR
   
   
   # AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])
   # ----------------------------------------------
 # Check hardcoding attributes.  # Check hardcoding attributes.
 AC_MSG_CHECKING([how to hardcode library paths into programs])  AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],
 hardcode_action=  [AC_MSG_CHECKING([how to hardcode library paths into programs])
 if test -n "$hardcode_libdir_flag_spec" || \  _LT_AC_TAGVAR(hardcode_action, $1)=
    test -n "$runpath_var"; then  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.    # We can hardcode non-existant directories.
   if test "$hardcode_direct" != no &&    if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&
      # If the only mechanism to avoid hardcoding is shlibpath_var, we       # If the only mechanism to avoid hardcoding is shlibpath_var, we
      # have to relink, otherwise we might link with an installed library       # have to relink, otherwise we might link with an installed library
      # when we should be linking with a yet-to-be-installed one       # when we should be linking with a yet-to-be-installed one
      ## test "$hardcode_shlibpath_var" != no &&       ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
      test "$hardcode_minus_L" != no; then       test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then
     # Linking always hardcodes the temporary library directory.      # Linking always hardcodes the temporary library directory.
     hardcode_action=relink      _LT_AC_TAGVAR(hardcode_action, $1)=relink
   else    else
     # We can link without hardcoding, and we can hardcode nonexisting dirs.      # We can link without hardcoding, and we can hardcode nonexisting dirs.
     hardcode_action=immediate      _LT_AC_TAGVAR(hardcode_action, $1)=immediate
   fi    fi
 else  else
   # We cannot hardcode anything, or else we can only hardcode existing    # We cannot hardcode anything, or else we can only hardcode existing
   # directories.    # directories.
   hardcode_action=unsupported    _LT_AC_TAGVAR(hardcode_action, $1)=unsupported
   fi
   AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])
   
   if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink; then
     # Fast installation is not supported
     enable_fast_install=no
   elif test "$shlibpath_overrides_runpath" = yes ||
        test "$enable_shared" = no; then
     # Fast installation is not necessary
     enable_fast_install=needless
 fi  fi
 AC_MSG_RESULT([$hardcode_action])  ])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH
   
 striplib=  
   # AC_LIBTOOL_SYS_LIB_STRIP
   # ------------------------
   AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],
   [striplib=
 old_striplib=  old_striplib=
 AC_MSG_CHECKING([whether stripping libraries is possible])  AC_MSG_CHECKING([whether stripping libraries is possible])
 if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then  if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then
Line 2021  if test -n "$STRIP" && $STRIP -V 2>&1 | Line 1608  if test -n "$STRIP" && $STRIP -V 2>&1 |
   test -z "$striplib" && striplib="$STRIP --strip-unneeded"    test -z "$striplib" && striplib="$STRIP --strip-unneeded"
   AC_MSG_RESULT([yes])    AC_MSG_RESULT([yes])
 else  else
   # FIXME - insert some real tests, host_os isn't really good enough
     case $host_os in
      darwin*)
          if test -n "$STRIP" ; then
            striplib="$STRIP -x"
            AC_MSG_RESULT([yes])
          else
   AC_MSG_RESULT([no])    AC_MSG_RESULT([no])
 fi  fi
          ;;
      *)
     AC_MSG_RESULT([no])
       ;;
     esac
   fi
   ])# AC_LIBTOOL_SYS_LIB_STRIP
   
 reload_cmds='$LD$reload_flag -o $output$reload_objs'  
 test -z "$deplibs_check_method" && deplibs_check_method=unknown  
   
   # AC_LIBTOOL_SYS_DYNAMIC_LINKER
   # -----------------------------
 # PORTME Fill in your ld.so characteristics  # PORTME Fill in your ld.so characteristics
 AC_MSG_CHECKING([dynamic linker characteristics])  AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],
   [AC_MSG_CHECKING([dynamic linker characteristics])
 library_names_spec=  library_names_spec=
 libname_spec='lib$name'  libname_spec='lib$name'
 soname_spec=  soname_spec=
   shrext_cmds=".so"
 postinstall_cmds=  postinstall_cmds=
 postuninstall_cmds=  postuninstall_cmds=
 finish_cmds=  finish_cmds=
Line 2041  shlibpath_overrides_runpath=unknown Line 1644  shlibpath_overrides_runpath=unknown
 version_type=none  version_type=none
 dynamic_linker="$host_os ld.so"  dynamic_linker="$host_os ld.so"
 sys_lib_dlsearch_path_spec="/lib /usr/lib"  sys_lib_dlsearch_path_spec="/lib /usr/lib"
 sys_lib_search_path_spec="/lib /usr/lib /usr/local/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"`
     fi
   else
     sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
   fi
   need_lib_prefix=unknown
   hardcode_into_libs=no
   
   # when you set need_version to no, make sure it does not cause -set_version
   # flags to be left without arguments
   need_version=unknown
   
 case $host_os in  case $host_os in
 aix3*)  aix3*)
   version_type=linux    version_type=linux
   library_names_spec='${libname}${release}.so$versuffix $libname.a'    library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
   shlibpath_var=LIBPATH    shlibpath_var=LIBPATH
   
   # AIX has no versioning support, so we append a major version to the name.    # AIX 3 has no versioning support, so we append a major version to the name.
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   ;;    ;;
   
 aix4* | aix5*)  aix4* | aix5*)
Line 2060  aix4* | aix5*) Line 1682  aix4* | aix5*)
   hardcode_into_libs=yes    hardcode_into_libs=yes
   if test "$host_cpu" = ia64; then    if test "$host_cpu" = ia64; then
     # AIX 5 supports IA64      # AIX 5 supports IA64
     library_names_spec='${libname}${release}.so$major ${libname}${release}.so$versuffix $libname.so'      library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
     shlibpath_var=LD_LIBRARY_PATH      shlibpath_var=LD_LIBRARY_PATH
   else    else
     # With GCC up to 2.95.x, collect2 would create an import file      # With GCC up to 2.95.x, collect2 would create an import file
Line 2070  aix4* | aix5*) Line 1692  aix4* | aix5*)
     # development snapshots of GCC prior to 3.0.      # development snapshots of GCC prior to 3.0.
     case $host_os in      case $host_os in
       aix4 | aix4.[[01]] | aix4.[[01]].*)        aix4 | aix4.[[01]] | aix4.[[01]].*)
         if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'        if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
              echo ' yes '             echo ' yes '
              echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then             echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
           :          :
         else        else
           can_build_shared=no          can_build_shared=no
         fi        fi
         ;;        ;;
     esac      esac
     # AIX (on Power*) has no versioning support, so currently we can      # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
     # not hardcode correct soname into executable. Probably we can      # soname into executable. Probably we can add versioning support to
     # add versioning support to collect2, so additional links can      # collect2, so additional links can be useful in future.
     # be useful in future.  
     if test "$aix_use_runtimelinking" = yes; then      if test "$aix_use_runtimelinking" = yes; then
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so        # 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        # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.        # typical AIX shared libraries.
       library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'        library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
     else      else
       # We preserve .a as extension for shared libraries through AIX4.2        # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.        # and later when we are not doing run time linking.
       library_names_spec='${libname}${release}.a $libname.a'        library_names_spec='${libname}${release}.a $libname.a'
       soname_spec='${libname}${release}.so$major'        soname_spec='${libname}${release}${shared_ext}$major'
     fi      fi
     shlibpath_var=LIBPATH      shlibpath_var=LIBPATH
   fi    fi
   hardcode_into_libs=yes  
   ;;    ;;
   
 amigaos*)  amigaos*)
   library_names_spec='$libname.ixlibrary $libname.a'    library_names_spec='$libname.ixlibrary $libname.a'
   # Create ${libname}_ixlibrary.a entries in /sys/libs.    # 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'    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*)  beos*)
   library_names_spec='${libname}.so'    library_names_spec='${libname}${shared_ext}'
   dynamic_linker="$host_os ld.so"    dynamic_linker="$host_os ld.so"
   shlibpath_var=LIBRARY_PATH    shlibpath_var=LIBRARY_PATH
   ;;    ;;
   
 bsdi4*)  bsdi[[45]]*)
   version_type=linux    version_type=linux
   need_version=no    need_version=no
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'    finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH    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_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"    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    # 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    # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
   # libtool to hard-code these into programs    # libtool to hard-code these into programs
Line 2128  bsdi4*) Line 1747  bsdi4*)
   
 cygwin* | mingw* | pw32*)  cygwin* | mingw* | pw32*)
   version_type=windows    version_type=windows
     shrext_cmds=".dll"
   need_version=no    need_version=no
   need_lib_prefix=no    need_lib_prefix=no
   
   case $GCC,$host_os in    case $GCC,$host_os in
   yes,cygwin*)    yes,cygwin* | yes,mingw* | yes,pw32*)
     library_names_spec='$libname.dll.a'      library_names_spec='$libname.dll.a'
     soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'      # DLL is installed to $(libdir)/../bin by postinstall_cmds
     postinstall_cmds='dlpath=`bash 2>&1 -c '\''. $dir/${file}i;echo \$dlname'\''`~      postinstall_cmds='base_file=`basename \${file}`~
         dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~        dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~        test -d \$dldir || mkdir -p \$dldir~
       $install_prog .libs/$dlname \$dldir/$dlname'        $install_prog $dir/$dlname \$dldir/$dlname~
     postuninstall_cmds='dldll=`bash 2>&1 -c '\''. $file; echo \$dlname'\''`~        chmod a+x \$dldir/$dlname'
       postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
       dlpath=$dir/\$dldll~        dlpath=$dir/\$dldll~
        $rm \$dlpath'         $rm \$dlpath'
       shlibpath_overrides_runpath=yes
   
       case $host_os in
       cygwin*)
         # Cygwin DLLs use 'cyg' prefix rather than 'lib'
         soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
         sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
         ;;
       mingw*)
         # MinGW DLLs use traditional 'lib' prefix
         soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
         sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
         if echo "$sys_lib_search_path_spec" | [grep ';[c-zC-Z]:/' >/dev/null]; then
           # It is most probably a Windows format PATH printed by
           # mingw gcc, but we are running on Cygwin. Gcc prints its search
           # path with ; separators, and with drive letters. We can handle the
           # drive letters (cygwin fileutils understands them), so leave them,
           # especially as we might pass files found there to a mingw objdump,
           # which wouldn't understand a cygwinified path. Ahh.
           sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
         else
           sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
         fi
         ;;
       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
     ;;      ;;
   yes,mingw*)  
     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"`  
     ;;  
   yes,pw32*)  
     library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll'  
     ;;  
   *)    *)
     library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll $libname.lib'      library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
     ;;      ;;
   esac    esac
   dynamic_linker='Win32 ld.exe'    dynamic_linker='Win32 ld.exe'
Line 2163  darwin* | rhapsody*) Line 1809  darwin* | rhapsody*)
   version_type=darwin    version_type=darwin
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   # FIXME: Relying on posixy $() will cause problems for    library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
   #        cross-compilation, but unfortunately the echo tests do not    soname_spec='${libname}${release}${major}$shared_ext'
   #        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_overrides_runpath=yes
   shlibpath_var=DYLD_LIBRARY_PATH    shlibpath_var=DYLD_LIBRARY_PATH
     shrext_cmds='`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
       sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
     else
       sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
     fi
     sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
     ;;
   
   dgux*)
     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
   ;;    ;;
   
 freebsd1*)  freebsd1*)
   dynamic_linker=no    dynamic_linker=no
   ;;    ;;
   
 freebsd*)  kfreebsd*-gnu)
   objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`    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'
     ;;
   
   freebsd* | dragonfly*)
     # DragonFly does not have aout.  When/if they implement a new
     # versioning mechanism, adjust this.
     if test -x /usr/bin/objformat; then
       objformat=`/usr/bin/objformat`
     else
       case $host_os in
       freebsd[[123]]*) objformat=aout ;;
       *) objformat=elf ;;
       esac
     fi
   version_type=freebsd-$objformat    version_type=freebsd-$objformat
   case $version_type in    case $version_type in
     freebsd-elf*)      freebsd-elf*)
       library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so'        library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
       need_version=no        need_version=no
       need_lib_prefix=no        need_lib_prefix=no
       ;;        ;;
     freebsd-*)      freebsd-*)
       library_names_spec='${libname}${release}.so$versuffix $libname.so$versuffix'        library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
       need_version=yes        need_version=yes
       ;;        ;;
   esac    esac
Line 2195  freebsd*) Line 1876  freebsd*)
   freebsd2*)    freebsd2*)
     shlibpath_overrides_runpath=yes      shlibpath_overrides_runpath=yes
     ;;      ;;
   *)    freebsd3.[[01]]* | freebsdelf3.[[01]]*)
       shlibpath_overrides_runpath=yes
       hardcode_into_libs=yes
       ;;
     *) # from 3.2 on
     shlibpath_overrides_runpath=no      shlibpath_overrides_runpath=no
     hardcode_into_libs=yes      hardcode_into_libs=yes
     ;;      ;;
Line 2206  gnu*) Line 1891  gnu*)
   version_type=linux    version_type=linux
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so${major} ${libname}.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
   hardcode_into_libs=yes    hardcode_into_libs=yes
   ;;    ;;
Line 2215  gnu*) Line 1900  gnu*)
 hpux9* | hpux10* | hpux11*)  hpux9* | hpux10* | hpux11*)
   # Give a soname corresponding to the major version so that dld.sl refuses to    # Give a soname corresponding to the major version so that dld.sl refuses to
   # link against other versions.    # link against other versions.
   dynamic_linker="$host_os dld.sl"  
   version_type=sunos    version_type=sunos
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   shlibpath_var=SHLIB_PATH    case $host_cpu in
   shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH    ia64*)
   library_names_spec='${libname}${release}.sl$versuffix ${libname}${release}.sl$major $libname.sl'      shrext_cmds='.so'
   soname_spec='${libname}${release}.sl$major'      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"
       fi
       sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
       ;;
      hppa*64*)
        shrext_cmds='.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_cmds='.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.    # HP-UX runs *really* slowly unless shared libraries are mode 555.
   postinstall_cmds='chmod 555 $lib'    postinstall_cmds='chmod 555 $lib'
   ;;    ;;
Line 2230  hpux9* | hpux10* | hpux11*) Line 1946  hpux9* | hpux10* | hpux11*)
 irix5* | irix6* | nonstopux*)  irix5* | irix6* | nonstopux*)
   case $host_os in    case $host_os in
     nonstopux*) version_type=nonstopux ;;      nonstopux*) version_type=nonstopux ;;
     *)          version_type=irix ;;      *)
           if test "$lt_cv_prog_gnu_ld" = yes; then
                   version_type=linux
           else
                   version_type=irix
           fi ;;
   esac    esac
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
   case $host_os in    case $host_os in
   irix5* | nonstopux*)    irix5* | nonstopux*)
     libsuff= shlibsuff=      libsuff= shlibsuff=
     ;;      ;;
   *)    *)
     case $LD in # libtool.m4 will add one of these switches to LD      case $LD in # libtool.m4 will add one of these switches to LD
     *-32|*"-32 ") libsuff= shlibsuff= libmagic=32-bit;;      *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
     *-n32|*"-n32 ") libsuff=32 shlibsuff=N32 libmagic=N32;;        libsuff= shlibsuff= libmagic=32-bit;;
     *-64|*"-64 ") libsuff=64 shlibsuff=64 libmagic=64-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;;      *) libsuff= shlibsuff= libmagic=never-match;;
     esac      esac
     ;;      ;;
Line 2253  irix5* | irix6* | nonstopux*) Line 1977  irix5* | irix6* | nonstopux*)
   shlibpath_overrides_runpath=no    shlibpath_overrides_runpath=no
   sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"    sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
   sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /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.  # No shared lib support for Linux oldld, aout, or coff.
 linux-gnuoldld* | linux-gnuaout* | linux-gnucoff*)  linux*oldld* | linux*aout* | linux*coff*)
   dynamic_linker=no    dynamic_linker=no
   ;;    ;;
   
 # This must be Linux ELF.  # This must be Linux ELF.
 linux-gnu*)  linux*)
   version_type=linux    version_type=linux
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'    finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=no    shlibpath_overrides_runpath=no
Line 2275  linux-gnu*) Line 2000  linux-gnu*)
   # before this can be enabled.    # before this can be enabled.
   hardcode_into_libs=yes    hardcode_into_libs=yes
   
     # Append ld.so.conf contents to the search path
     if test -f /etc/ld.so.conf; then
       lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,    ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
       sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
     fi
   
   # We used to test for /lib/ld.so.1 and disable shared libraries on    # We used to test for /lib/ld.so.1 and disable shared libraries on
   # powerpc, because MkLinux only supported shared libraries with the    # powerpc, because MkLinux only supported shared libraries with the
   # GNU dynamic linker.  Since this was broken with cross compilers,    # GNU dynamic linker.  Since this was broken with cross compilers,
Line 2284  linux-gnu*) Line 2015  linux-gnu*)
   dynamic_linker='GNU/Linux ld.so'    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*)  netbsd*)
   version_type=sunos    version_type=sunos
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
     library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
     finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'      finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
     dynamic_linker='NetBSD (a.out) ld.so'      dynamic_linker='NetBSD (a.out) ld.so'
   else    else
     library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so ${libname}.so'      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
     soname_spec='${libname}${release}.so$major'      soname_spec='${libname}${release}${shared_ext}$major'
     dynamic_linker='NetBSD ld.elf_so'      dynamic_linker='NetBSD ld.elf_so'
   fi    fi
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
Line 2304  netbsd*) Line 2047  netbsd*)
   
 newsos6)  newsos6)
   version_type=linux    version_type=linux
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    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_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes    shlibpath_overrides_runpath=yes
   ;;    ;;
Line 2312  newsos6) Line 2065  newsos6)
 openbsd*)  openbsd*)
   version_type=sunos    version_type=sunos
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
     case $host_os in
       openbsd3.3 | openbsd3.3.*) need_version=yes ;;
       *)                         need_version=no  ;;
     esac
     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    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
     case "$host_os" in      case $host_os in
     openbsd2.[[89]] | openbsd2.[[89]].*)        openbsd2.[[89]] | openbsd2.[[89]].*)
       shlibpath_overrides_runpath=no          shlibpath_overrides_runpath=no
       ;;          ;;
     *)        *)
       shlibpath_overrides_runpath=yes          shlibpath_overrides_runpath=yes
       ;;          ;;
     esac        esac
   else    else
     shlibpath_overrides_runpath=yes      shlibpath_overrides_runpath=yes
   fi    fi
   library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'  
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'  
   shlibpath_var=LD_LIBRARY_PATH  
   ;;  
   
 openedition*)  
   need_lib_prefix=no  
   need_version=no  
   shlibpath_overrides_runpath=yes  
   shlibpath_var=LIBPATH  
   postinstall_cmds="rm \$destdir/\$linkname; cp \$linkname \$destdir; chmod a+x \$lib"  
   # the library's exports are in libname.x; this is the file that must  
   # actually be linked with to use a DLL.  
   library_names_spec="\${libname}\${release}.so\$versuffix \${libname}.x"  
   ;;    ;;
   
 os2*)  os2*)
   libname_spec='$name'    libname_spec='$name'
     shrext_cmds=".dll"
   need_lib_prefix=no    need_lib_prefix=no
   library_names_spec='$libname.dll $libname.a'    library_names_spec='$libname${shared_ext} $libname.a'
   dynamic_linker='OS/2 ld.exe'    dynamic_linker='OS/2 ld.exe'
   shlibpath_var=LIBPATH    shlibpath_var=LIBPATH
   ;;    ;;
   
 osf3* | osf4* | osf5*)  osf3* | osf4* | osf5*)
   version_type=osf    version_type=osf
     need_lib_prefix=no
   need_version=no    need_version=no
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
   shlibpath_var=LD_LIBRARY_PATH    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_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"    sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
   hardcode_into_libs=yes  
   ;;    ;;
   
 sco3.2v5*)  sco3.2v5*)
   version_type=osf    version_type=osf
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
   ;;    ;;
   
Line 2371  solaris*) Line 2118  solaris*)
   version_type=linux    version_type=linux
   need_lib_prefix=no    need_lib_prefix=no
   need_version=no    need_version=no
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes    shlibpath_overrides_runpath=yes
   hardcode_into_libs=yes    hardcode_into_libs=yes
Line 2382  solaris*) Line 2129  solaris*)
   
 sunos4*)  sunos4*)
   version_type=sunos    version_type=sunos
   library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
   finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'    finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
   shlibpath_overrides_runpath=yes    shlibpath_overrides_runpath=yes
Line 2394  sunos4*) Line 2141  sunos4*)
   
 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)  sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
   version_type=linux    version_type=linux
   library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
   soname_spec='${libname}${release}.so$major'    soname_spec='${libname}${release}${shared_ext}$major'
   shlibpath_var=LD_LIBRARY_PATH    shlibpath_var=LD_LIBRARY_PATH
   case $host_vendor in    case $host_vendor in
     sni)      sni)
Line 2416  sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) Line 2163  sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
   esac    esac
   ;;    ;;
   
 uts4*)  
   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  
   ;;  
   
 dgux*)  
   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  
   ;;  
   
 sysv4*MP*)  sysv4*MP*)
   if test -d /usr/nec ;then    if test -d /usr/nec ;then
     version_type=linux      version_type=linux
     library_names_spec='$libname.so.$versuffix $libname.so.$major $libname.so'      library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
     soname_spec='$libname.so.$major'      soname_spec='$libname${shared_ext}.$major'
     shlibpath_var=LD_LIBRARY_PATH      shlibpath_var=LD_LIBRARY_PATH
   fi    fi
   ;;    ;;
   
   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    dynamic_linker=no
   ;;    ;;
 esac  esac
 AC_MSG_RESULT([$dynamic_linker])  AC_MSG_RESULT([$dynamic_linker])
 test "$dynamic_linker" = no && can_build_shared=no  test "$dynamic_linker" = no && can_build_shared=no
   ])# AC_LIBTOOL_SYS_DYNAMIC_LINKER
   
   
   # _LT_AC_TAGCONFIG
   # ----------------
   AC_DEFUN([_LT_AC_TAGCONFIG],
   [AC_ARG_WITH([tags],
       [AC_HELP_STRING([--with-tags@<:@=TAGS@:>@],
           [include additional configurations @<:@automatic@:>@])],
       [tagnames="$withval"])
   
   if test -f "$ltmain" && test -n "$tagnames"; then
     if test ! -f "${ofile}"; then
       AC_MSG_WARN([output file `$ofile' does not exist])
     fi
   
     if test -z "$LTCC"; then
       eval "`$SHELL ${ofile} --config | grep '^LTCC='`"
       if test -z "$LTCC"; then
         AC_MSG_WARN([output file `$ofile' does not look like a libtool script])
       else
         AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile'])
       fi
     fi
   
     # 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])
       fi
   
       # 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" &&
               ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
               (test "X$CXX" != "Xg++"))) ; then
             AC_LIBTOOL_LANG_CXX_CONFIG
           else
             tagname=""
           fi
           ;;
   
         F77)
           if test -n "$F77" && test "X$F77" != "Xno"; then
             AC_LIBTOOL_LANG_F77_CONFIG
           else
             tagname=""
           fi
           ;;
   
         GCJ)
           if test -n "$GCJ" && test "X$GCJ" != "Xno"; then
             AC_LIBTOOL_LANG_GCJ_CONFIG
           else
             tagname=""
           fi
           ;;
   
         RC)
           AC_LIBTOOL_LANG_RC_CONFIG
           ;;
   
         *)
           AC_MSG_ERROR([Unsupported tag name: $tagname])
           ;;
         esac
   
         # Append the new tag name to the list of available tags.
         if test -n "$tagname" ; then
         available_tags="$available_tags $tagname"
       fi
       fi
     done
     IFS="$lt_save_ifs"
   
     # Now substitute the updated list of available tags.
     if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then
       mv "${ofile}T" "$ofile"
       chmod +x "$ofile"
     else
       rm -f "${ofile}T"
       AC_MSG_ERROR([unable to update list of available tagged configurations.])
     fi
   fi
   ])# _LT_AC_TAGCONFIG
   
   
   # AC_LIBTOOL_DLOPEN
   # -----------------
   # enable checks for dlopen support
   AC_DEFUN([AC_LIBTOOL_DLOPEN],
    [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])
   ])# AC_LIBTOOL_DLOPEN
   
   
   # AC_LIBTOOL_WIN32_DLL
   # --------------------
   # declare package support for building win32 DLLs
   AC_DEFUN([AC_LIBTOOL_WIN32_DLL],
   [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])
   ])# AC_LIBTOOL_WIN32_DLL
   
   
   # AC_ENABLE_SHARED([DEFAULT])
   # ---------------------------
   # implement the --enable-shared flag
   # DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
   AC_DEFUN([AC_ENABLE_SHARED],
   [define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl
   AC_ARG_ENABLE([shared],
       [AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
           [build shared libraries @<:@default=]AC_ENABLE_SHARED_DEFAULT[@:>@])],
       [p=${PACKAGE-default}
       case $enableval in
       yes) enable_shared=yes ;;
       no) enable_shared=no ;;
       *)
         enable_shared=no
         # Look at the argument we got.  We use all the common list separators.
         lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
         for pkg in $enableval; do
           IFS="$lt_save_ifs"
           if test "X$pkg" = "X$p"; then
             enable_shared=yes
           fi
         done
         IFS="$lt_save_ifs"
         ;;
       esac],
       [enable_shared=]AC_ENABLE_SHARED_DEFAULT)
   ])# AC_ENABLE_SHARED
   
   
   # AC_DISABLE_SHARED
   # -----------------
   #- set the default shared flag to --disable-shared
   AC_DEFUN([AC_DISABLE_SHARED],
   [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
   AC_ENABLE_SHARED(no)
   ])# AC_DISABLE_SHARED
   
   
   # 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
         # Look at the argument we got.  We use all the common list separators.
         lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
         for pkg in $enableval; do
           IFS="$lt_save_ifs"
           if test "X$pkg" = "X$p"; then
             enable_static=yes
           fi
         done
         IFS="$lt_save_ifs"
         ;;
       esac],
       [enable_static=]AC_ENABLE_STATIC_DEFAULT)
   ])# AC_ENABLE_STATIC
   
 # Report the final consequences.  
   # AC_DISABLE_STATIC
   # -----------------
   # set the default static flag to --disable-static
   AC_DEFUN([AC_DISABLE_STATIC],
   [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
   AC_ENABLE_STATIC(no)
   ])# AC_DISABLE_STATIC
   
   
   # AC_ENABLE_FAST_INSTALL([DEFAULT])
   # ---------------------------------
   # implement the --enable-fast-install flag
   # DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
   AC_DEFUN([AC_ENABLE_FAST_INSTALL],
   [define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl
   AC_ARG_ENABLE([fast-install],
       [AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
       [optimize for fast installation @<:@default=]AC_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
       [p=${PACKAGE-default}
       case $enableval in
       yes) enable_fast_install=yes ;;
       no) enable_fast_install=no ;;
       *)
         enable_fast_install=no
         # Look at the argument we got.  We use all the common list separators.
         lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
         for pkg in $enableval; do
           IFS="$lt_save_ifs"
           if test "X$pkg" = "X$p"; then
             enable_fast_install=yes
           fi
         done
         IFS="$lt_save_ifs"
         ;;
       esac],
       [enable_fast_install=]AC_ENABLE_FAST_INSTALL_DEFAULT)
   ])# AC_ENABLE_FAST_INSTALL
   
   
   # AC_DISABLE_FAST_INSTALL
   # -----------------------
   # set the default to --disable-fast-install
   AC_DEFUN([AC_DISABLE_FAST_INSTALL],
   [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
   AC_ENABLE_FAST_INSTALL(no)
   ])# AC_DISABLE_FAST_INSTALL
   
   
   # AC_LIBTOOL_PICMODE([MODE])
   # --------------------------
   # implement the --with-pic flag
   # MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
   AC_DEFUN([AC_LIBTOOL_PICMODE],
   [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
   pic_mode=ifelse($#,1,$1,default)
   ])# AC_LIBTOOL_PICMODE
   
   
   # AC_PROG_EGREP
   # -------------
   # This is predefined starting with Autoconf 2.54, so this conditional
   # definition can be removed once we require Autoconf 2.54 or later.
   m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP],
   [AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],
      [if echo a | (grep -E '(a|b)') >/dev/null 2>&1
       then ac_cv_prog_egrep='grep -E'
       else ac_cv_prog_egrep='egrep'
       fi])
    EGREP=$ac_cv_prog_egrep
    AC_SUBST([EGREP])
   ])])
   
   
   # AC_PATH_TOOL_PREFIX
   # -------------------
   # find a file program which can recognise shared library
   AC_DEFUN([AC_PATH_TOOL_PREFIX],
   [AC_REQUIRE([AC_PROG_EGREP])dnl
   AC_MSG_CHECKING([for $1])
   AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
   [case $MAGIC_CMD in
   [[\\/*] |  ?:[\\/]*])
     lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
     ;;
   *)
     lt_save_MAGIC_CMD="$MAGIC_CMD"
     lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   dnl $ac_dummy forces splitting on constant user-supplied paths.
   dnl POSIX.2 word splitting is done only on the output of word expansions,
   dnl not every word.  This closes a longstanding sh security hole.
     ac_dummy="ifelse([$2], , $PATH, [$2])"
     for ac_dir in $ac_dummy; do
       IFS="$lt_save_ifs"
       test -z "$ac_dir" && ac_dir=.
       if test -f $ac_dir/$1; then
         lt_cv_path_MAGIC_CMD="$ac_dir/$1"
         if test -n "$file_magic_test_file"; then
           case $deplibs_check_method in
           "file_magic "*)
             file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
             MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
             if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
               $EGREP "$file_magic_regex" > /dev/null; then
               :
             else
               cat <<EOF 1>&2
   
   *** Warning: the command libtool uses to detect shared libraries,
   *** $file_magic_cmd, produces output that libtool cannot recognize.
   *** 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
             fi ;;
           esac
         fi
         break
       fi
     done
     IFS="$lt_save_ifs"
     MAGIC_CMD="$lt_save_MAGIC_CMD"
     ;;
   esac])
   MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
   if test -n "$MAGIC_CMD"; then
     AC_MSG_RESULT($MAGIC_CMD)
   else
     AC_MSG_RESULT(no)
   fi
   ])# AC_PATH_TOOL_PREFIX
   
   
   # AC_PATH_MAGIC
   # -------------
   # find a file program which can recognise a shared library
   AC_DEFUN([AC_PATH_MAGIC],
   [AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
   if test -z "$lt_cv_path_MAGIC_CMD"; then
     if test -n "$ac_tool_prefix"; then
       AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
     else
       MAGIC_CMD=:
     fi
   fi
   ])# AC_PATH_MAGIC
   
   
   # AC_PROG_LD
   # ----------
   # find the pathname to the GNU or non-GNU linker
   AC_DEFUN([AC_PROG_LD],
   [AC_ARG_WITH([gnu-ld],
       [AC_HELP_STRING([--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([LT_AC_PROG_SED])dnl
   AC_REQUIRE([AC_PROG_CC])dnl
   AC_REQUIRE([AC_CANONICAL_HOST])dnl
   AC_REQUIRE([AC_CANONICAL_BUILD])dnl
   ac_prog=ld
   if test "$GCC" = yes; then
     # Check if gcc -print-prog-name=ld gives a path.
     AC_MSG_CHECKING([for ld used by $CC])
     case $host in
     *-*-mingw*)
       # gcc leaves a trailing carriage return which upsets mingw
       ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
     *)
       ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
     esac
     case $ac_prog in
       # Accept absolute paths.
       [[\\/]]* | ?:[[\\/]]*)
         re_direlt='/[[^/]][[^/]]*/\.\./'
         # Canonicalize the pathname of ld
         ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
         while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
           ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
         done
         test -z "$LD" && LD="$ac_prog"
         ;;
     "")
       # If it fails, then pretend we aren't using GCC.
       ac_prog=ld
       ;;
     *)
       # 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])
   fi
   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 variants of GNU ld only accept -v.
         # Break only if it was the GNU/non-GNU ld that we prefer.
         case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
         *GNU* | *'with BFD'*)
           test "$with_gnu_ld" != no && break
           ;;
         *)
           test "$with_gnu_ld" != yes && break
           ;;
         esac
       fi
     done
     IFS="$lt_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)
   fi
   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 lds 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
     ;;
   esac])
   with_gnu_ld=$lt_cv_prog_gnu_ld
   ])# AC_PROG_LD_GNU
   
   
   # AC_PROG_LD_RELOAD_FLAG
   # ----------------------
   # find reload flag for linker
   #   -- PORTME Some linkers may need a different reload flag.
   AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],
   [AC_CACHE_CHECK([for $LD option to reload object files],
     lt_cv_ld_reload_flag,
     [lt_cv_ld_reload_flag='-r'])
   reload_flag=$lt_cv_ld_reload_flag
   case $reload_flag in
   "" | " "*) ;;
   *) reload_flag=" $reload_flag" ;;
   esac
   reload_cmds='$LD$reload_flag -o $output$reload_objs'
   case $host_os in
     darwin*)
       if test "$GCC" = yes; then
         reload_cmds='$CC -nostdlib ${wl}-r -o $output$reload_objs'
       else
         reload_cmds='$LD$reload_flag -o $output$reload_objs'
       fi
       ;;
   esac
   ])# AC_PROG_LD_RELOAD_FLAG
   
   
   # AC_DEPLIBS_CHECK_METHOD
   # -----------------------
   # how to check for library dependencies
   #  -- PORTME fill in with the dynamic library characteristics
   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
   aix4* | aix5*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   beos*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   bsdi[[45]]*)
     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*)
     # func_win32_libid is a shell function defined in ltmain.sh
     lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
     lt_cv_file_magic_cmd='func_win32_libid'
     ;;
   
   mingw* | pw32*)
     # Base MSYS/MinGW do not provide the 'file' command needed by
     # func_win32_libid shell function, so use a weaker test based on 'objdump'.
     lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
     lt_cv_file_magic_cmd='$OBJDUMP -f'
     ;;
   
   darwin* | rhapsody*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   freebsd* | kfreebsd*-gnu | dragonfly*)
     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|DragonFly)/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
     fi
     ;;
   
   gnu*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   hpux10.20* | hpux11*)
     lt_cv_file_magic_cmd=/usr/bin/file
     case $host_cpu in
     ia64*)
       lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
       lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
       ;;
     hppa*64*)
       [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']
       lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
       ;;
     *)
       lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
       lt_cv_file_magic_test_file=/usr/lib/libc.sl
       ;;
     esac
     ;;
   
   irix5* | irix6* | nonstopux*)
     case $LD in
     *-32|*"-32 ") libmagic=32-bit;;
     *-n32|*"-n32 ") libmagic=N32;;
     *-64|*"-64 ") libmagic=64-bit;;
     *) libmagic=never-match;;
     esac
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   # This must be Linux ELF.
   linux*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   netbsd*)
     if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
       lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
     else
       lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
     fi
     ;;
   
   newos6*)
     lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
     lt_cv_file_magic_cmd=/usr/bin/file
     lt_cv_file_magic_test_file=/usr/lib/libnls.so
     ;;
   
   nto-qnx*)
     lt_cv_deplibs_check_method=unknown
     ;;
   
   openbsd*)
     if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
       lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
     else
       lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
     fi
     ;;
   
   osf3* | osf4* | osf5*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   sco3.2v5*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   solaris*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   
   sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
     case $host_vendor in
     motorola)
       lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
       ;;
     ncr)
       lt_cv_deplibs_check_method=pass_all
       ;;
     sequent)
       lt_cv_file_magic_cmd='/bin/file'
       lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
       ;;
     sni)
       lt_cv_file_magic_cmd='/bin/file'
       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)
       lt_cv_deplibs_check_method=pass_all
       ;;
     esac
     ;;
   
   sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*)
     lt_cv_deplibs_check_method=pass_all
     ;;
   esac
   ])
   file_magic_cmd=$lt_cv_file_magic_cmd
   deplibs_check_method=$lt_cv_deplibs_check_method
   test -z "$deplibs_check_method" && deplibs_check_method=unknown
   ])# AC_DEPLIBS_CHECK_METHOD
   
   
   # AC_PROG_NM
   # ----------
   # find the pathname to a BSD-compatible name lister
   AC_DEFUN([AC_PROG_NM],
   [AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,
   [if test -n "$NM"; then
     # Let the user override the test.
     lt_cv_path_NM="$NM"
   else
     lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
       IFS="$lt_save_ifs"
       test -z "$ac_dir" && ac_dir=.
       tmp_nm="$ac_dir/${ac_tool_prefix}nm"
       if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
         # Check to see if the nm accepts a BSD-compat flag.
         # Adding the `sed 1q' prevents false positives on HP-UX, which says:
         #   nm: unknown option "B" ignored
         # Tru64's nm complains that /dev/null is an invalid object file
         case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
         */dev/null* | *'Invalid file or object type'*)
           lt_cv_path_NM="$tmp_nm -B"
           break
           ;;
         *)
           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
         esac
       fi
     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
   
   
   # AC_CHECK_LIBM
   # -------------
   # check for math library
   AC_DEFUN([AC_CHECK_LIBM],
   [AC_REQUIRE([AC_CANONICAL_HOST])dnl
   LIBM=
   case $host in
   *-*-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")
     AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
     ;;
   *)
     AC_CHECK_LIB(m, cos, LIBM="-lm")
     ;;
   esac
   ])# AC_CHECK_LIBM
   
   
   # AC_LIBLTDL_CONVENIENCE([DIRECTORY])
   # -----------------------------------
   # sets LIBLTDL to the link flags for the libltdl convenience library and
   # LTDLINCL to the include flags for the libltdl header and adds
   # --enable-ltdl-convenience to the configure arguments.  Note that
   # AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,
   # 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.
   AC_DEFUN([AC_LIBLTDL_CONVENIENCE],
   [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
     case $enable_ltdl_convenience in
     no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
     "") enable_ltdl_convenience=yes
         ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
     esac
     LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la
     LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
     # For backwards non-gettext consistent compatibility...
     INCLTDL="$LTDLINCL"
   ])# AC_LIBLTDL_CONVENIENCE
   
   
   # AC_LIBLTDL_INSTALLABLE([DIRECTORY])
   # -----------------------------------
   # sets LIBLTDL to the link flags for the libltdl installable library and
   # LTDLINCL to the include flags for the libltdl header and adds
   # --enable-ltdl-install to the configure arguments.  Note that
   # AC_CONFIG_SUBDIRS is not called here.  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 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
      fi
     ])
     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"
       LIBLTDL="-lltdl"
       LTDLINCL=
     fi
     # 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([_LT_AC_PROG_CXXCPP])
   _LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX])
   ])# _LT_AC_LANG_CXX
   
   # _LT_AC_PROG_CXXCPP
   # ---------------
   AC_DEFUN([_LT_AC_PROG_CXXCPP],
   [
   AC_REQUIRE([AC_PROG_CXX])
   if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
       ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
       (test "X$CXX" != "Xg++"))) ; then
     AC_PROG_CXXCPP
   fi
   ])# _LT_AC_PROG_CXXCPP
   
   # 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
   
   # save warnings/boilerplate of simple test code
   _LT_COMPILER_BOILERPLATE
   _LT_LINKER_BOILERPLATE
   
   #
   # 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
   fi
   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
     fi
   fi
   
   
   #
   # 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)
   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)
   
   # Report which librarie types wil actually be built
 AC_MSG_CHECKING([if libtool supports shared libraries])  AC_MSG_CHECKING([if libtool supports shared libraries])
 AC_MSG_RESULT([$can_build_shared])  AC_MSG_RESULT([$can_build_shared])
   
Line 2457  test "$can_build_shared" = "no" && enabl Line 3113  test "$can_build_shared" = "no" && enabl
   
 # On AIX, shared libraries and static libraries use the same namespace, and  # On AIX, shared libraries and static libraries use the same namespace, and
 # are all built from PIC.  # are all built from PIC.
 case "$host_os" in  case $host_os in
 aix3*)  aix3*)
   test "$enable_shared" = yes && enable_static=no    test "$enable_shared" = yes && enable_static=no
   if test -n "$RANLIB"; then    if test -n "$RANLIB"; then
Line 2466  aix3*) Line 3122  aix3*)
   fi    fi
   ;;    ;;
   
 aix4*)  aix4* | aix5*)
   if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
     test "$enable_shared" = yes && enable_static=no      test "$enable_shared" = yes && enable_static=no
   fi    fi
   ;;      ;;
 esac  esac
 AC_MSG_RESULT([$enable_shared])  AC_MSG_RESULT([$enable_shared])
   
Line 2479  AC_MSG_CHECKING([whether to build static Line 3135  AC_MSG_CHECKING([whether to build static
 test "$enable_shared" = yes || enable_static=yes  test "$enable_shared" = yes || enable_static=yes
 AC_MSG_RESULT([$enable_static])  AC_MSG_RESULT([$enable_static])
   
 if test "$hardcode_action" = relink; then  AC_LIBTOOL_CONFIG($1)
   # Fast installation is not supported  
   enable_fast_install=no  AC_LANG_POP
 elif test "$shlibpath_overrides_runpath" = yes ||  CC="$lt_save_CC"
      test "$enable_shared" = no; then  ])# AC_LIBTOOL_LANG_C_CONFIG
   # Fast installation is not necessary  
   enable_fast_install=needless  
   # 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([_LT_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=cpp
   
   # 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
   
   # save warnings/boilerplate of simple test code
   _LT_COMPILER_BOILERPLATE
   _LT_LINKER_BOILERPLATE
   
   # 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
   fi
   if test -n "${lt_cv_path_LDCXX+set}"; then
     lt_cv_path_LD=$lt_cv_path_LDCXX
   else
     unset lt_cv_path_LD
   fi
   test -z "${LDCXX+set}" || LD=$LDCXX
   CC=${CXX-"c++"}
   compiler=$CC
   _LT_AC_TAGVAR(compiler, $1)=$CC
   _LT_CC_BASENAME([$compiler])
   
   # 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)=
 fi  fi
   
 variables_saved_for_relink="PATH $shlibpath_var $runpath_var"  if test "$GXX" = yes; then
 if test "$GCC" = yes; then    # Set up default GNU C++ configuration
   variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"  
     AC_PROG_LD
   
     # Check if GNU C++ uses GNU ld as the underlying linker, since the
     # archiving commands below assume that GNU ld is being used.
     if test "$with_gnu_ld" = yes; then
       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
       _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
   
       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
       _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
   
       # If archive_cmds runs LD, not CC, wlarc should be empty
       # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
       #     investigate it a little bit more. (MM)
       wlarc='${wl}'
   
       # ancient GNU ld didn't support --whole-archive et. al.
       if eval "`$CC -print-prog-name=ld` --help 2>&1" | \
           grep 'no-whole-archive' > /dev/null; then
         _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
       else
         _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
       fi
     else
       with_gnu_ld=no
       wlarc=
   
       # A generic and very simple default shared library creation
       # command for GNU C++ for the case where it uses the native
       # linker, instead of GNU ld.  If possible, this setting should
       # overridden to take advantage of the native linker features on
       # the platform it is being used on.
       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
     fi
   
     # Commands to make compiler produce verbose output that lists
     # what "hidden" libraries, object files and flags are used when
     # linking a shared library.
     output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'
   
   else
     GXX=no
     with_gnu_ld=no
     wlarc=
 fi  fi
   
 AC_LIBTOOL_DLOPEN_SELF  # 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
       _LT_AC_TAGVAR(ld_shlibs, $1)=no
       ;;
     aix4* | aix5*)
       if test "$host_cpu" = ia64; then
         # On IA64, the linker does run time linking by default, so we don't
         # have to do anything special.
         aix_use_runtimelinking=no
         exp_sym_flag='-Bexport'
         no_entry_flag=""
       else
         aix_use_runtimelinking=no
   
 if test "$enable_shared" = yes && test "$GCC" = yes; then        # Test if we are trying to use run time linking or normal
   case $archive_cmds in        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
   *'~'*)        # need to do runtime linking.
     # FIXME: we may have to deal with multi-command sequences.        case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
     ;;          for ld_flag in $LDFLAGS; do
   '$CC '*)            case $ld_flag in
     # Test whether the compiler implicitly links with -lc since on some            *-brtl*)
     # systems, -lgcc has to come before -lc. If gcc already passes -lc              aix_use_runtimelinking=yes
     # to ld, don't add -lc before -lgcc.              break
     AC_MSG_CHECKING([whether -lc should be explicitly linked in])              ;;
     AC_CACHE_VAL([lt_cv_archive_cmds_need_lc],            esac
     [$rm conftest*          done
     echo 'static int dummy;' > conftest.$ac_ext        esac
   
     if AC_TRY_EVAL(ac_compile); then        exp_sym_flag='-bexport'
       soname=conftest        no_entry_flag='-bnoentry'
       lib=conftest      fi
       libobjs=conftest.$ac_objext  
       deplibs=      # When large executables or shared objects are built, AIX ld can
       wl=$lt_cv_prog_cc_wl      # have problems creating the table of contents.  If linking a library
       compiler_flags=-v      # or program results in "error TOC overflow" add -mminimal-toc to
       linker_flags=-v      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
       verstring=      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
       output_objdir=.  
       libname=conftest      _LT_AC_TAGVAR(archive_cmds, $1)=''
       save_allow_undefined_flag=$allow_undefined_flag      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
       allow_undefined_flag=      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
       if AC_TRY_EVAL(archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1)      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
       then  
         lt_cv_archive_cmds_need_lc=no      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
           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)=
           fi
         esac
         shared_flag='-shared'
         if test "$aix_use_runtimelinking" = yes; then
           shared_flag="$shared_flag "'${wl}-G'
         fi
       else
         # not using gcc
         if test "$host_cpu" = ia64; then
           # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
           # chokes on -Wl,-G. The following line is correct:
           shared_flag='-G'
       else        else
         lt_cv_archive_cmds_need_lc=yes          if test "$aix_use_runtimelinking" = yes; then
             shared_flag='${wl}-G'
           else
             shared_flag='${wl}-bM:SRE'
           fi
       fi        fi
       allow_undefined_flag=$save_allow_undefined_flag      fi
   
       # It seems that -bexpall does not export symbols beginning with
       # underscore (_), so it is better to generate a list of symbols to export.
       _LT_AC_TAGVAR(always_export_symbols, $1)=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'
         # 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"
   
         _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'
           _LT_AC_TAGVAR(allow_undefined_flag, $1)="-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"
         else
           # 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"
           # 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'
           _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
           # -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
           _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 its 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'
         fi
       fi
       ;;
     chorus*)
       case $cc_basename in
         *)
           # FIXME: insert proper C++ library support
           _LT_AC_TAGVAR(ld_shlibs, $1)=no
           ;;
       esac
       ;;
   
   
     cygwin* | mingw* | pw32*)
       # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
       # as there is no search path for DLLs.
       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
       _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 -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $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 -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      else
       cat conftest.err 1>&5        _LT_AC_TAGVAR(ld_shlibs, $1)=no
     fi])      fi
     AC_MSG_RESULT([$lt_cv_archive_cmds_need_lc])    ;;
         darwin* | rhapsody*)
           case $host_os in
           rhapsody* | darwin1.[[012]])
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
            ;;
          *) # Darwin 1.3 on
            if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
              _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
            else
              case ${MACOSX_DEPLOYMENT_TARGET} in
                10.[[012]])
                  _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
                  ;;
                10.*)
                  _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
                  ;;
              esac
            fi
            ;;
           esac
         _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
         _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)=''
         _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
   
       if test "$GXX" = yes ; then
         lt_int_apple_cc_single_mod=no
         output_verbose_link_cmd='echo'
         if $CC -dumpspecs 2>&1 | $EGREP 'single_module' >/dev/null ; then
          lt_int_apple_cc_single_mod=yes
         fi
         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(archive_cmds, $1)='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
           fi
           _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
           # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
             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(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
             fi
               _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}'
         else
         case $cc_basename in
           xlc*)
            output_verbose_link_cmd='echo'
             _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
             _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
             # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
             _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$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(ld_shlibs, $1)=no
             ;;
         esac
         fi
           ;;
   
     dgux*)
       case $cc_basename in
         ec++*)
           # FIXME: insert proper C++ library support
           _LT_AC_TAGVAR(ld_shlibs, $1)=no
           ;;
         ghcx*)
           # Green Hills C++ Compiler
           # 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
     ;;      ;;
   esac    freebsd[[12]]*)
 fi      # C++ shared libraries reported to be fairly broken before switch to ELF
 need_lc=${lt_cv_archive_cmds_need_lc-yes}      _LT_AC_TAGVAR(ld_shlibs, $1)=no
       ;;
     freebsd-elf*)
       _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
       ;;
     freebsd* | kfreebsd*-gnu | dragonfly*)
       # 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
       CC*)
         # FIXME: insert proper C++ library support
         _LT_AC_TAGVAR(ld_shlibs, $1)=no
         ;;
       aCC*)
         _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) | 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
           _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'
         else
           # FIXME: insert proper C++ library support
           _LT_AC_TAGVAR(ld_shlibs, $1)=no
         fi
         ;;
       esac
       ;;
     hpux10*|hpux11*)
       if test $with_gnu_ld = no; then
         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)=:
           ;;
         ia64*)
           _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
           ;;
         *)
           _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'
           ;;
         esac
       fi
       case $host_cpu in
       hppa*64*)
         _LT_AC_TAGVAR(hardcode_direct, $1)=no
         _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
         ;;
       ia64*)
         _LT_AC_TAGVAR(hardcode_direct, $1)=no
         _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
         _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
                                                 # but as the default
                                                 # location of the library.
         ;;
       *)
         _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.
         ;;
       esac
   
 # The second clause should only fire when bootstrapping the      case $cc_basename in
 # libtool distribution, otherwise you forgot to ship ltmain.sh        CC*)
 # with your package, and you will get complaints that there are          # FIXME: insert proper C++ library support
 # no rules to generate ltmain.sh.          _LT_AC_TAGVAR(ld_shlibs, $1)=no
 if test -f "$ltmain"; then          ;;
   :        aCC*)
           case $host_cpu in
           hppa*64*|ia64*)
             _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
             ;;
           *)
             _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'
             ;;
           esac
           # 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) | 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'
                 ;;
               esac
             fi
           else
             # FIXME: insert proper C++ library support
             _LT_AC_TAGVAR(ld_shlibs, $1)=no
           fi
           ;;
       esac
       ;;
     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 ${output_objdir}/so_locations -o $lib'
   
           # Archives containing C++ object files must be created using
           # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
           # necessary to make sure instantiated templates are included
           # in the archive.
           _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}${output_objdir}/so_locations -o $lib'
             else
               _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` -o $lib'
             fi
           fi
           _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
           # version 8.0 and above of icpc choke on multiply defined symbols
           # if we add $predep_objects and $postdep_objects, however 7.1 and
           # earlier do not add the objects themselves.
           case `$CC -V 2>&1` in
           *"Version 7."*)
             _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'
             ;;
           *)  # Version 8.0 or newer
             tmp_idyn=
             case $host_cpu in
               ia64*) tmp_idyn=' -i_dynamic';;
             esac
             _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
             _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
             ;;
           esac
           _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
           _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'
           ;;
         pgCC*)
           # Portland Group C++ compiler
           _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
           _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $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'
           _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_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'
   
           runpath_var=LD_RUN_PATH
           _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $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"`; 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
       ;;
     lynxos*)
       # FIXME: insert proper C++ library support
       _LT_AC_TAGVAR(ld_shlibs, $1)=no
       ;;
     m88k*)
       # FIXME: insert proper C++ library support
       _LT_AC_TAGVAR(ld_shlibs, $1)=no
       ;;
     mvs*)
       case $cc_basename in
         cxx*)
           # 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
       ;;
     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
       fi
       # Workaround some broken pre-1.5 toolchains
       output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
       ;;
     openbsd2*)
       # C++ shared libraries are fairly broken
       _LT_AC_TAGVAR(ld_shlibs, $1)=no
       ;;
     openbsd*)
       _LT_AC_TAGVAR(hardcode_direct, $1)=yes
       _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
       if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
         _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
         _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
         _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
       fi
       output_verbose_link_cmd='echo'
       ;;
     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(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(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 ${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)=:
   
           # 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}${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)=:
   
             # 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
             # FIXME: insert proper C++ library support
             _LT_AC_TAGVAR(ld_shlibs, $1)=no
           fi
           ;;
       esac
       ;;
     osf4* | osf5*)
       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(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
           _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
   
           # Archives containing C++ object files must be created using
           # the KAI C++ compiler.
           _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -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)=' -expect_unresolved \*'
           _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 ${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~
             $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 ${output_objdir}/so_locations -o $lib~
             $rm $lib.exp'
   
           _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $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}-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_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"'
   
           else
             # FIXME: insert proper C++ library support
             _LT_AC_TAGVAR(ld_shlibs, $1)=no
           fi
           ;;
       esac
       ;;
     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(archive_cmds_need_lc,$1)=yes
           _LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'
           _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -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}  ${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. We must also pass each convience library through
               # to the system linker between allextract/defaultextract.
               # The C++ compiler will combine linker options so we
               # cannot just pass the convience library names through
               # without $wl.
               # Supported since Solaris 2.6 (maybe 2.5.1?)
               _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'
               ;;
           esac
           _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
   
           output_verbose_link_cmd='echo'
   
           # 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.
           _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
           ;;
         *)
           # 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
               # 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
               # 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\""
             fi
   
             _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
           fi
           ;;
       esac
       ;;
     sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)
       _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
       ;;
     tandem*)
       case $cc_basename in
         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
           _LT_AC_TAGVAR(ld_shlibs, $1)=no
           ;;
       esac
       ;;
     vxworks*)
       # 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
   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"
   _LT_AC_TAGVAR(LD, $1)="$LD"
   
   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])
   # ------------------------
   # Figure out "hidden" library dependencies from verbose
   # compiler output when linking a shared library.
   # Parse the compiler output and extract the necessary
   # objects, libraries and library flags.
   AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[
   dnl we can't use the lt_simple_compile_test_code here,
   dnl because it contains code intended for an executable,
   dnl not a library.  It's possible we should let each
   dnl tag define a new lt_????_link_test_code variable,
   dnl but it's only used here...
   ifelse([$1],[],[cat > conftest.$ac_ext <<EOF
   int a;
   void foo (void) { a = 0; }
   EOF
   ],[$1],[CXX],[cat > conftest.$ac_ext <<EOF
   class Foo
   {
   public:
     Foo (void) { a = 0; }
   private:
     int a;
   };
   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
     # the conftest object file.
     pre_test_object_deps_done=no
   
     # The `*' in the case matches for architectures that use `case' in
     # $output_verbose_cmd can trigger glob expansion during the loop
     # eval without this substitution.
     output_verbose_link_cmd=`$echo "X$output_verbose_link_cmd" | $Xsed -e "$no_glob_subst"`
   
     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=
          fi
   
          if test "$pre_test_object_deps_done" = no; then
            case $p in
            -L* | -R*)
              # Internal compiler library paths should come after those
              # provided the user.  The postdeps already come after the
              # user supplied libs so there is no need to process them.
              if test -z "$_LT_AC_TAGVAR(compiler_lib_search_path, $1)"; then
                _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
              else
                _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${_LT_AC_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
              fi
              ;;
            # The "-l" case would never come before the object being
            # linked, so don't bother handling this case.
            esac
          else
            if test -z "$_LT_AC_TAGVAR(postdeps, $1)"; then
              _LT_AC_TAGVAR(postdeps, $1)="${prev}${p}"
            else
              _LT_AC_TAGVAR(postdeps, $1)="${_LT_AC_TAGVAR(postdeps, $1)} ${prev}${p}"
            fi
          fi
          ;;
   
       *.$objext)
          # This assumes that the test object file only shows up
          # once in the compiler output.
          if test "$p" = "conftest.$objext"; then
            pre_test_object_deps_done=yes
            continue
          fi
   
          if test "$pre_test_object_deps_done" = no; then
            if test -z "$_LT_AC_TAGVAR(predep_objects, $1)"; then
              _LT_AC_TAGVAR(predep_objects, $1)="$p"
            else
              _LT_AC_TAGVAR(predep_objects, $1)="$_LT_AC_TAGVAR(predep_objects, $1) $p"
            fi
          else
            if test -z "$_LT_AC_TAGVAR(postdep_objects, $1)"; then
              _LT_AC_TAGVAR(postdep_objects, $1)="$p"
            else
              _LT_AC_TAGVAR(postdep_objects, $1)="$_LT_AC_TAGVAR(postdep_objects, $1) $p"
            fi
          fi
          ;;
   
       *) ;; # Ignore the rest.
   
       esac
     done
   
     # Clean up.
     rm -f a.out a.exe
 else  else
   # If there is no Makefile yet, we rely on a make rule to execute    echo "libtool.m4: error: problem compiling $1 test program"
   # `config.status --recheck' to rerun these tests and create the  
   # libtool script then.  
   test -f Makefile && make "$ltmain"  
 fi  fi
   
 if test -f "$ltmain"; then  $rm -f confest.$objext
   trap "$rm \"${ofile}T\"; exit 1" 1 2 15  
   $rm -f "${ofile}T"  # PORTME: override above test on systems where it is broken
   ifelse([$1],[CXX],
   [case $host_os in
   solaris*)
     case $cc_basename in
     CC*)
       # Adding this requires a known-good setup of shared libraries for
       # Sun compiler versions before 5.6, else PIC objects from an old
       # archive will be linked into the output, leading to subtle bugs.
       _LT_AC_TAGVAR(postdeps,$1)='-lCstd -lCrun'
       ;;
     esac
   esac
   ])
   
   case " $_LT_AC_TAGVAR(postdeps, $1) " in
   *" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;
   esac
   ])# AC_LIBTOOL_POSTDEP_PREDEP
   
   # AC_LIBTOOL_LANG_F77_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_F77_CONFIG], [_LT_AC_LANG_F77_CONFIG(F77)])
   AC_DEFUN([_LT_AC_LANG_F77_CONFIG],
   [AC_REQUIRE([AC_PROG_F77])
   AC_LANG_PUSH(Fortran 77)
   
   _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
   
   # Source file extension for f77 test sources.
   ac_ext=f
   
   # Object file extension for compiled f77 test sources.
   objext=o
   _LT_AC_TAGVAR(objext, $1)=$objext
   
   # Code to be used in simple compile tests
   lt_simple_compile_test_code="      subroutine t\n      return\n      end\n"
   
   # Code to be used in simple link tests
   lt_simple_link_test_code="      program t\n      end\n"
   
   # ltmain only uses $CC for tagged configurations so make sure $CC is set.
   _LT_AC_SYS_COMPILER
   
   # save warnings/boilerplate of simple test code
   _LT_COMPILER_BOILERPLATE
   _LT_LINKER_BOILERPLATE
   
   # Allow CC to be a program name with arguments.
   lt_save_CC="$CC"
   CC=${F77-"f77"}
   compiler=$CC
   _LT_AC_TAGVAR(compiler, $1)=$CC
   _LT_CC_BASENAME([$compiler])
   
   AC_MSG_CHECKING([if libtool supports shared libraries])
   AC_MSG_RESULT([$can_build_shared])
   
   AC_MSG_CHECKING([whether to build shared libraries])
   test "$can_build_shared" = "no" && enable_shared=no
   
   # On AIX, shared libraries and static libraries use the same namespace, and
   # are all built from PIC.
   case $host_os in
   aix3*)
     test "$enable_shared" = yes && enable_static=no
     if test -n "$RANLIB"; then
       archive_cmds="$archive_cmds~\$RANLIB \$lib"
       postinstall_cmds='$RANLIB $lib'
     fi
     ;;
   aix4* | aix5*)
     if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
       test "$enable_shared" = yes && enable_static=no
     fi
     ;;
   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])
   
   test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
   
   _LT_AC_TAGVAR(GCC, $1)="$G77"
   _LT_AC_TAGVAR(LD, $1)="$LD"
   
   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_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
   
   # save warnings/boilerplate of simple test code
   _LT_COMPILER_BOILERPLATE
   _LT_LINKER_BOILERPLATE
   
   # Allow CC to be a program name with arguments.
   lt_save_CC="$CC"
   CC=${GCJ-"gcj"}
   compiler=$CC
   _LT_AC_TAGVAR(compiler, $1)=$CC
   _LT_CC_BASENAME([$compiler])
   
   # GCJ did not exist at the time GCC didn't implicitly link libc in.
   _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
   
   _LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
   
   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
   
   echo creating $ofile  
   
   # 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
   
   # save warnings/boilerplate of simple test code
   _LT_COMPILER_BOILERPLATE
   _LT_LINKER_BOILERPLATE
   
   # Allow CC to be a program name with arguments.
   lt_save_CC="$CC"
   CC=${RC-"windres"}
   compiler=$CC
   _LT_AC_TAGVAR(compiler, $1)=$CC
   _LT_CC_BASENAME([$compiler])
   _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
   
   AC_LIBTOOL_CONFIG($1)
   
   AC_LANG_RESTORE
   CC="$lt_save_CC"
   ])# AC_LIBTOOL_LANG_RC_CONFIG
   
   
   # AC_LIBTOOL_CONFIG([TAGNAME])
   # ----------------------------
   # 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.
     if test -n "${ZSH_VERSION+set}" ; then
       setopt NO_GLOB_SUBST
     fi
   # Now quote all the things that may contain metacharacters while being    # Now quote all the things that may contain metacharacters while being
   # careful not to overquote the AC_SUBSTed values.  We take copies of the    # careful not to overquote the AC_SUBSTed values.  We take copies of the
   # variables and quote the copies for generation of the libtool script.    # variables and quote the copies for generation of the libtool script.
   for var in echo old_CC old_CFLAGS SED \    for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \
     AR AR_FLAGS CC LD LN_S NM SHELL \      SED SHELL STRIP \
     reload_flag reload_cmds wl \      libname_spec library_names_spec soname_spec extract_expsyms_cmds \
     pic_flag link_static_flag no_builtin_flag export_dynamic_flag_spec \      old_striplib striplib file_magic_cmd finish_cmds finish_eval \
     thread_safe_flag_spec whole_archive_flag_spec libname_spec \      deplibs_check_method reload_flag reload_cmds need_locks \
     library_names_spec soname_spec \      lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \
     RANLIB old_archive_cmds old_archive_from_new_cmds old_postinstall_cmds \      lt_cv_sys_global_symbol_to_c_name_address \
     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 \      sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
     compiler_c_o compiler_o_lo need_locks exclude_expsyms include_expsyms; do      old_postinstall_cmds old_postuninstall_cmds \
       _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      case $var in
     reload_cmds | old_archive_cmds | old_archive_from_new_cmds | \      _LT_AC_TAGVAR(old_archive_cmds, $1) | \
     old_postinstall_cmds | old_postuninstall_cmds | \      _LT_AC_TAGVAR(old_archive_from_new_cmds, $1) | \
     export_symbols_cmds | archive_cmds | archive_expsym_cmds | \      _LT_AC_TAGVAR(archive_cmds, $1) | \
     extract_expsyms_cmds | old_archive_from_expsyms_cmds | \      _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 | \      postinstall_cmds | postuninstall_cmds | \
     finish_cmds | sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)      old_postinstall_cmds | old_postuninstall_cmds | \
       sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
       # Double-quote double-evaled strings.        # Double-quote double-evaled strings.
       eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""        eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
       ;;        ;;
Line 2593  if test -f "$ltmain"; then Line 4534  if test -f "$ltmain"; then
     esac      esac
   done    done
   
   cat <<__EOF__ > "${ofile}T"    case $lt_echo in
 #! $SHELL    *'\[$]0 --fallback-echo"')
       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 "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.  # `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
 # Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)  # Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)
 # NOTE: Changes made to this file will be lost: look at ltmain.sh.  # NOTE: Changes made to this file will be lost: look at ltmain.sh.
 #  #
 # Copyright (C) 1996-2000 Free Software Foundation, Inc.  # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
   # Free Software Foundation, Inc.
   #
   # This file is part of GNU Libtool:
 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996  # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 #  #
 # This program is free software; you can redistribute it and/or modify  # This program is free software; you can redistribute it and/or modify
Line 2615  if test -f "$ltmain"; then Line 4573  if test -f "$ltmain"; then
 #  #
 # You should have received a copy of the GNU General Public License  # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software  # along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #  #
 # As a special exception to the GNU General Public License, if you  # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a  # distribute this file as part of a program that contains a
 # configuration script generated by Autoconf, you may include it under  # configuration script generated by Autoconf, you may include it under
 # the same distribution terms that you use for the rest of that program.  # the same distribution terms that you use for the rest of that program.
   
 # A sed that does not truncate output.  # A sed program that does not truncate output.
 SED=$lt_SED  SED=$lt_SED
   
 # Sed that helps us avoid accidentally triggering echo(1) options like -n.  # Sed that helps us avoid accidentally triggering echo(1) options like -n.
 Xsed="${SED} -e s/^X//"  Xsed="$SED -e 1s/^X//"
   
 # The HP-UX ksh and POSIX shell print the target directory to stdout  # The HP-UX ksh and POSIX shell print the target directory to stdout
 # if CDPATH is set.  # if CDPATH is set.
 if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi  (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
   
   # The names of the tagged configurations supported by this script.
   available_tags=
   
 # ### BEGIN LIBTOOL CONFIG  # ### BEGIN LIBTOOL CONFIG],
   [# ### BEGIN LIBTOOL TAG CONFIG: $tagname])
   
 # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:  # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
   
Line 2646  build_libtool_libs=$enable_shared Line 4608  build_libtool_libs=$enable_shared
 build_old_libs=$enable_static  build_old_libs=$enable_static
   
 # Whether or not to add -lc for building shared libraries.  # Whether or not to add -lc for building shared libraries.
 build_libtool_need_lc=$need_lc  build_libtool_need_lc=$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)
   
   # 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.  # Whether or not to optimize for fast installation.
 fast_install=$enable_fast_install  fast_install=$enable_fast_install
Line 2654  fast_install=$enable_fast_install Line 4619  fast_install=$enable_fast_install
 # The host system.  # The host system.
 host_alias=$host_alias  host_alias=$host_alias
 host=$host  host=$host
   host_os=$host_os
   
   # The build system.
   build_alias=$build_alias
   build=$build
   build_os=$build_os
   
 # An echo program that does not interpret backslashes.  # An echo program that does not interpret backslashes.
 echo=$lt_echo  echo=$lt_echo
Line 2662  echo=$lt_echo Line 4633  echo=$lt_echo
 AR=$lt_AR  AR=$lt_AR
 AR_FLAGS=$lt_AR_FLAGS  AR_FLAGS=$lt_AR_FLAGS
   
 # The default C compiler.  # A C compiler.
 CC=$lt_CC  LTCC=$lt_LTCC
   
   # A language-specific compiler.
   CC=$lt_[]_LT_AC_TAGVAR(compiler, $1)
   
 # Is the compiler the GNU C compiler?  # Is the compiler the GNU C compiler?
 with_gcc=$GCC  with_gcc=$_LT_AC_TAGVAR(GCC, $1)
   
   # An ERE matcher.
   EGREP=$lt_EGREP
   
 # The linker used to build libraries.  # The linker used to build libraries.
 LD=$lt_LD  LD=$lt_[]_LT_AC_TAGVAR(LD, $1)
   
 # Whether we need hard or soft links.  # Whether we need hard or soft links.
 LN_S=$lt_LN_S  LN_S=$lt_LN_S
Line 2678  LN_S=$lt_LN_S Line 4655  LN_S=$lt_LN_S
 NM=$lt_NM  NM=$lt_NM
   
 # A symbol stripping program  # A symbol stripping program
 STRIP=$STRIP  STRIP=$lt_STRIP
   
 # Used to examine libraries when file_magic_cmd begins "file"  # Used to examine libraries when file_magic_cmd begins "file"
 MAGIC_CMD=$MAGIC_CMD  MAGIC_CMD=$MAGIC_CMD
Line 2700  reload_flag=$lt_reload_flag Line 4677  reload_flag=$lt_reload_flag
 reload_cmds=$lt_reload_cmds  reload_cmds=$lt_reload_cmds
   
 # How to pass a linker flag through the compiler.  # How to pass a linker flag through the compiler.
 wl=$lt_wl  wl=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)
   
 # Object file suffix (normally "o").  # Object file suffix (normally "o").
 objext="$ac_objext"  objext="$ac_objext"
Line 2708  objext="$ac_objext" Line 4685  objext="$ac_objext"
 # Old archive suffix (normally "a").  # Old archive suffix (normally "a").
 libext="$libext"  libext="$libext"
   
   # Shared library suffix (normally ".so").
   shrext_cmds='$shrext_cmds'
   
 # Executable file suffix (normally "").  # Executable file suffix (normally "").
 exeext="$exeext"  exeext="$exeext"
   
 # Additional compiler flags for building library objects.  # Additional compiler flags for building library objects.
 pic_flag=$lt_pic_flag  pic_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)
 pic_mode=$pic_mode  pic_mode=$pic_mode
   
 # Does compiler simultaneously support -c and -o options?  # What is the maximum length of a command?
 compiler_c_o=$lt_compiler_c_o  max_cmd_len=$lt_cv_sys_max_cmd_len
   
 # Can we write directly to a .lo ?  # Does compiler simultaneously support -c and -o options?
 compiler_o_lo=$lt_compiler_o_lo  compiler_c_o=$lt_[]_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)
   
 # Must we lock files when doing compilation ?  # Must we lock files when doing compilation?
 need_locks=$lt_need_locks  need_locks=$lt_need_locks
   
 # Do we need the lib prefix for modules?  # Do we need the lib prefix for modules?
Line 2740  dlopen_self=$enable_dlopen_self Line 4720  dlopen_self=$enable_dlopen_self
 dlopen_self_static=$enable_dlopen_self_static  dlopen_self_static=$enable_dlopen_self_static
   
 # Compiler flag to prevent dynamic linking.  # Compiler flag to prevent dynamic linking.
 link_static_flag=$lt_link_static_flag  link_static_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_static, $1)
   
 # Compiler flag to turn off builtin functions.  # Compiler flag to turn off builtin functions.
 no_builtin_flag=$lt_no_builtin_flag  no_builtin_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)
   
 # Compiler flag to allow reflexive dlopens.  # Compiler flag to allow reflexive dlopens.
 export_dynamic_flag_spec=$lt_export_dynamic_flag_spec  export_dynamic_flag_spec=$lt_[]_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)
   
 # Compiler flag to generate shared objects directly from archives.  # Compiler flag to generate shared objects directly from archives.
 whole_archive_flag_spec=$lt_whole_archive_flag_spec  whole_archive_flag_spec=$lt_[]_LT_AC_TAGVAR(whole_archive_flag_spec, $1)
   
 # Compiler flag to generate thread-safe objects.  # Compiler flag to generate thread-safe objects.
 thread_safe_flag_spec=$lt_thread_safe_flag_spec  thread_safe_flag_spec=$lt_[]_LT_AC_TAGVAR(thread_safe_flag_spec, $1)
   
 # Library versioning type.  # Library versioning type.
 version_type=$version_type  version_type=$version_type
Line 2769  soname_spec=$lt_soname_spec Line 4749  soname_spec=$lt_soname_spec
   
 # Commands used to build and install an old-style archive.  # Commands used to build and install an old-style archive.
 RANLIB=$lt_RANLIB  RANLIB=$lt_RANLIB
 old_archive_cmds=$lt_old_archive_cmds  old_archive_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_cmds, $1)
 old_postinstall_cmds=$lt_old_postinstall_cmds  old_postinstall_cmds=$lt_old_postinstall_cmds
 old_postuninstall_cmds=$lt_old_postuninstall_cmds  old_postuninstall_cmds=$lt_old_postuninstall_cmds
   
 # Create an old-style archive from a shared archive.  # Create an old-style archive from a shared archive.
 old_archive_from_new_cmds=$lt_old_archive_from_new_cmds  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.  # Create a temporary old-style archive to link instead of a shared archive.
 old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds  old_archive_from_expsyms_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)
   
 # Commands used to build and install a shared archive.  # Commands used to build and install a shared archive.
 archive_cmds=$lt_archive_cmds  archive_cmds=$lt_[]_LT_AC_TAGVAR(archive_cmds, $1)
 archive_expsym_cmds=$lt_archive_expsym_cmds  archive_expsym_cmds=$lt_[]_LT_AC_TAGVAR(archive_expsym_cmds, $1)
 postinstall_cmds=$lt_postinstall_cmds  postinstall_cmds=$lt_postinstall_cmds
 postuninstall_cmds=$lt_postuninstall_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.  # Commands to strip libraries.
 old_striplib=$lt_old_striplib  old_striplib=$lt_old_striplib
 striplib=$lt_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.  # Method to check whether dependent libraries are shared objects.
 deplibs_check_method=$lt_deplibs_check_method  deplibs_check_method=$lt_deplibs_check_method
   
Line 2796  deplibs_check_method=$lt_deplibs_check_m Line 4800  deplibs_check_method=$lt_deplibs_check_m
 file_magic_cmd=$lt_file_magic_cmd  file_magic_cmd=$lt_file_magic_cmd
   
 # Flag that allows shared libraries with undefined symbols to be built.  # Flag that allows shared libraries with undefined symbols to be built.
 allow_undefined_flag=$lt_allow_undefined_flag  allow_undefined_flag=$lt_[]_LT_AC_TAGVAR(allow_undefined_flag, $1)
   
 # Flag that forces no undefined symbols.  # Flag that forces no undefined symbols.
 no_undefined_flag=$lt_no_undefined_flag  no_undefined_flag=$lt_[]_LT_AC_TAGVAR(no_undefined_flag, $1)
   
 # Commands used to finish a libtool library installation in a directory.  # Commands used to finish a libtool library installation in a directory.
 finish_cmds=$lt_finish_cmds  finish_cmds=$lt_finish_cmds
Line 2808  finish_cmds=$lt_finish_cmds Line 4812  finish_cmds=$lt_finish_cmds
 finish_eval=$lt_finish_eval  finish_eval=$lt_finish_eval
   
 # Take the output of nm and produce a listing of raw symbols and C names.  # Take the output of nm and produce a listing of raw symbols and C names.
 global_symbol_pipe=$lt_global_symbol_pipe  global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
   
 # Transform the output of nm in a proper C declaration  # Transform the output of nm in a proper C declaration
 global_symbol_to_cdecl=$lt_global_symbol_to_cdecl  global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
   
 # Transform the output of nm in a C name address pair  # Transform the output of nm in a C name address pair
 global_symbol_to_c_name_address=$lt_global_symbol_to_c_name_address  global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
   
 # This is the shared library runtime path variable.  # This is the shared library runtime path variable.
 runpath_var=$runpath_var  runpath_var=$runpath_var
Line 2826  shlibpath_var=$shlibpath_var Line 4830  shlibpath_var=$shlibpath_var
 shlibpath_overrides_runpath=$shlibpath_overrides_runpath  shlibpath_overrides_runpath=$shlibpath_overrides_runpath
   
 # How to hardcode a shared library path into an executable.  # How to hardcode a shared library path into an executable.
 hardcode_action=$hardcode_action  hardcode_action=$_LT_AC_TAGVAR(hardcode_action, $1)
   
 # Whether we should hardcode library paths into libraries.  # Whether we should hardcode library paths into libraries.
 hardcode_into_libs=$hardcode_into_libs  hardcode_into_libs=$hardcode_into_libs
   
 # Flag to hardcode \$libdir into a binary during linking.  # Flag to hardcode \$libdir into a binary during linking.
 # This must work even if \$libdir does not exist.  # This must work even if \$libdir does not exist.
 hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec  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.  # Whether we need a single -rpath flag with a separated argument.
 hardcode_libdir_separator=$lt_hardcode_libdir_separator  hardcode_libdir_separator=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_separator, $1)
   
 # Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the  # Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the
 # resulting binary.  # resulting binary.
 hardcode_direct=$hardcode_direct  hardcode_direct=$_LT_AC_TAGVAR(hardcode_direct, $1)
   
 # Set to yes if using the -LDIR flag during linking hardcodes DIR into the  # Set to yes if using the -LDIR flag during linking hardcodes DIR into the
 # resulting binary.  # resulting binary.
 hardcode_minus_L=$hardcode_minus_L  hardcode_minus_L=$_LT_AC_TAGVAR(hardcode_minus_L, $1)
   
 # Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into  # Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
 # the resulting binary.  # the resulting binary.
 hardcode_shlibpath_var=$hardcode_shlibpath_var  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  # Variables whose values should be saved in libtool wrapper scripts and
 # restored at relink time.  # restored at relink time.
 variables_saved_for_relink="$variables_saved_for_relink"  variables_saved_for_relink="$variables_saved_for_relink"
   
 # Whether libtool must link a program against all its dependency libraries.  # Whether libtool must link a program against all its dependency libraries.
 link_all_deplibs=$link_all_deplibs  link_all_deplibs=$_LT_AC_TAGVAR(link_all_deplibs, $1)
   
 # Compile-time system search path for libraries  # Compile-time system search path for libraries
 sys_lib_search_path_spec=$lt_sys_lib_search_path_spec  sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
Line 2864  sys_lib_search_path_spec=$lt_sys_lib_sea Line 4877  sys_lib_search_path_spec=$lt_sys_lib_sea
 sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec  sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
   
 # Fix the shell variable \$srcfile for the compiler.  # Fix the shell variable \$srcfile for the compiler.
 fix_srcfile_path="$fix_srcfile_path"  fix_srcfile_path="$_LT_AC_TAGVAR(fix_srcfile_path, $1)"
   
 # Set to yes if exported symbols are required.  # Set to yes if exported symbols are required.
 always_export_symbols=$always_export_symbols  always_export_symbols=$_LT_AC_TAGVAR(always_export_symbols, $1)
   
 # The commands to list exported symbols.  # The commands to list exported symbols.
 export_symbols_cmds=$lt_export_symbols_cmds  export_symbols_cmds=$lt_[]_LT_AC_TAGVAR(export_symbols_cmds, $1)
   
 # The commands to extract the exported symbol list from a shared archive.  # The commands to extract the exported symbol list from a shared archive.
 extract_expsyms_cmds=$lt_extract_expsyms_cmds  extract_expsyms_cmds=$lt_extract_expsyms_cmds
   
 # Symbols that should not be listed in the preloaded symbols.  # Symbols that should not be listed in the preloaded symbols.
 exclude_expsyms=$lt_exclude_expsyms  exclude_expsyms=$lt_[]_LT_AC_TAGVAR(exclude_expsyms, $1)
   
 # Symbols that must always be exported.  # Symbols that must always be exported.
 include_expsyms=$lt_include_expsyms  include_expsyms=$lt_[]_LT_AC_TAGVAR(include_expsyms, $1)
   
 # ### END LIBTOOL CONFIG  ifelse([$1],[],
   [# ### END LIBTOOL CONFIG],
   [# ### END LIBTOOL TAG CONFIG: $tagname])
   
 __EOF__  __EOF__
   
   ifelse([$1],[], [
   case $host_os in    case $host_os in
   aix3*)    aix3*)
     cat <<\EOF >> "${ofile}T"      cat <<\EOF >> "$cfgfile"
   
 # AIX sometimes has problems with the GCC collect2 program.  For some  # AIX sometimes has problems with the GCC collect2 program.  For some
 # reason, if we set the COLLECT_NAMES environment variable, the problems  # reason, if we set the COLLECT_NAMES environment variable, the problems
Line 2900  EOF Line 4916  EOF
     ;;      ;;
   esac    esac
   
   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 */  
 # /*   Copyright (C) 1999-2000 Free Software Foundation, Inc.  
 #  
 #  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;  
 #  
 #     nexp = pe_as32 (expdata+24);  
 #     name_rvas = pe_as32 (expdata+32);  
 #  
 #     printf ("EXPORTS\n");  
 #     for (i = 0; i<nexp; i++)  
 #     {  
 #       unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);  
 #       printf ("\t%s @ %ld ;\n", erva+name_rva, 1+ i);  
 #     }  
 #  
 #     return 0;  
 # }  
 # /* impgen.c ends here */  
   
 EOF  
     ;;  
   esac  
   
   # We use sed instead of cat because bash on DJGPP gets confused if    # 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    # 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    # text mode, it properly converts lines to CR/LF.  This bash problem
   # is reportedly fixed, but why not run on old versions too?    # is reportedly fixed, but why not run on old versions too?
   sed '$q' "$ltmain" >> "${ofile}T" || (rm -f "${ofile}T"; exit 1)    sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)
   
   mv -f "${ofile}T" "$ofile" || \    mv -f "$cfgfile" "$ofile" || \
     (rm -f "$ofile" && cp "${ofile}T" "$ofile" && rm -f "${ofile}T")      (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
   chmod +x "$ofile"    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"
     fi
 fi  fi
   ])# AC_LIBTOOL_CONFIG
   
 ])# _LT_AC_LTCONFIG_HACK  
   
 # AC_LIBTOOL_DLOPEN - enable checks for dlopen support  
 AC_DEFUN([AC_LIBTOOL_DLOPEN], [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])])  
   
 # AC_LIBTOOL_WIN32_DLL - declare package support for building win32 dll's  # AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME])
 AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])])  # -------------------------------------------
   AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI],
   [AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
   
 # AC_ENABLE_SHARED - implement the --enable-shared flag  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
 # 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  
     fi  
   done  
   IFS="$ac_save_ifs"  
   ;;  
 esac],  
 enable_shared=AC_ENABLE_SHARED_DEFAULT)dnl  
 ])  
   
 # AC_DISABLE_SHARED - set the default shared flag to --disable-shared  if test "$GCC" = yes; then
 AC_DEFUN([AC_DISABLE_SHARED],    _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
 [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl  
 AC_ENABLE_SHARED(no)])  
   
 # AC_ENABLE_STATIC - implement the --enable-static flag    AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
 # Usage: AC_ENABLE_STATIC[(DEFAULT)]      lt_cv_prog_compiler_rtti_exceptions,
 #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to      [-fno-rtti -fno-exceptions], [],
 #   `yes'.      [_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_DEFUN([AC_ENABLE_STATIC],  fi
 [define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl  ])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI
 AC_ARG_ENABLE(static,  
 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  
     fi  
   done  
   IFS="$ac_save_ifs"  
   ;;  
 esac],  
 enable_static=AC_ENABLE_STATIC_DEFAULT)dnl  
 ])  
   
 # AC_DISABLE_STATIC - set the default static flag to --disable-static  
 AC_DEFUN([AC_DISABLE_STATIC],  
 [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl  
 AC_ENABLE_STATIC(no)])  
   
   # 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?!! ;)]
   
 # AC_ENABLE_FAST_INSTALL - implement the --enable-fast-install flag  # Character class describing NM global symbol codes.
 # Usage: AC_ENABLE_FAST_INSTALL[(DEFAULT)]  symcode='[[BCDEGRST]]'
 #   Where DEFAULT is either `yes' or `no'.  If omitted, it defaults to  
 #   `yes'.  
 AC_DEFUN([AC_ENABLE_FAST_INSTALL],  
 [define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl  
 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  
     fi  
   done  
   IFS="$ac_save_ifs"  
   ;;  
 esac],  
 enable_fast_install=AC_ENABLE_FAST_INSTALL_DEFAULT)dnl  
 ])  
   
 # AC_DISABLE_FAST_INSTALL - set the default to --disable-fast-install  # Regexp to match symbols that can be accessed directly from C.
 AC_DEFUN([AC_DISABLE_FAST_INSTALL],  sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
 [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl  
 AC_ENABLE_FAST_INSTALL(no)])  
   
 # AC_LIBTOOL_PICMODE - implement the --with-pic flag  # Transform an extracted symbol line into a proper C declaration
 # Usage: AC_LIBTOOL_PICMODE[(MODE)]  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
 #   Where 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)])  
   
   # 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'"
   
 # AC_PATH_TOOL_PREFIX - find a file program which can recognise shared library  # Define system-specific variables.
 AC_DEFUN([AC_PATH_TOOL_PREFIX],  case $host_os in
 [AC_MSG_CHECKING([for $1])  aix*)
 AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,    symcode='[[BCDT]]'
 [case $MAGIC_CMD in  
   /*)  
   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.  
   ;;    ;;
   ?:/*)  cygwin* | mingw* | pw32*)
   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.    symcode='[[ABCDGISTW]]'
   ;;    ;;
   *)  hpux*) # Its linker distinguishes data from code symbols
   ac_save_MAGIC_CMD="$MAGIC_CMD"    if test "$host_cpu" = ia64; then
   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"      symcode='[[ABCDEGRST]]'
 dnl $ac_dummy forces splitting on constant user-supplied paths.    fi
 dnl POSIX.2 word splitting is done only on the output of word expansions,    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
 dnl not every word.  This closes a longstanding sh security hole.    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'"
   ac_dummy="ifelse([$2], , $PATH, [$2])"    ;;
   for ac_dir in $ac_dummy; do  linux*)
     test -z "$ac_dir" && ac_dir=.    if test "$host_cpu" = ia64; then
     if test -f $ac_dir/$1; then      symcode='[[ABCDGIRSTW]]'
       lt_cv_path_MAGIC_CMD="$ac_dir/$1"      lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
       if test -n "$file_magic_test_file"; then      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'"
         case $deplibs_check_method in    fi
         "file_magic "*)    ;;
           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"  irix* | nonstopux*)
           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"    symcode='[[BCDEGRST]]'
           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |    ;;
             egrep "$file_magic_regex" > /dev/null; then  osf*)
             :    symcode='[[BCDEGQRST]]'
           else    ;;
             cat <<EOF 1>&2  solaris* | sysv5*)
     symcode='[[BDRT]]'
     ;;
   sysv4)
     symcode='[[DFNSTU]]'
     ;;
   esac
   
 *** Warning: the command libtool uses to detect shared libraries,  # Handle CRLF in mingw tool chain
 *** $file_magic_cmd, produces output that libtool cannot recognize.  opt_cr=
 *** The result is that libtool may fail to recognize shared libraries  case $build_os in
 *** as such.  This will affect the creation of libtool libraries that  mingw*)
 *** depend on shared libraries, but programs linked with such libtool    opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
 *** libraries will work regardless of this problem.  Nevertheless, you    ;;
 *** may want to report the problem to your system manager and/or to  esac
 *** bug-libtool@gnu.org  
   # 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
   
     # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
     symxfrm="\\1 $ac_symprfx\\2 \\2"
   
     # 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  EOF
           fi ;;  
         esac    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
       fi        fi
       break  
         # 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
             fi
             LIBS="$lt_save_LIBS"
             CFLAGS="$lt_save_CFLAGS"
           else
             echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
           fi
         else
           echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
         fi
       else
         echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
     fi      fi
   done    else
   IFS="$ac_save_ifs"      echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
   MAGIC_CMD="$ac_save_MAGIC_CMD"      cat conftest.$ac_ext >&5
   ;;    fi
 esac])    rm -f conftest* conftst*
 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"  
 if test -n "$MAGIC_CMD"; then    # Do not use the global_symbol_pipe unless it works.
   AC_MSG_RESULT($MAGIC_CMD)    if test "$pipe_works" = yes; then
       break
     else
       lt_cv_sys_global_symbol_pipe=
     fi
   done
   ])
   if test -z "$lt_cv_sys_global_symbol_pipe"; then
     lt_cv_sys_global_symbol_to_cdecl=
   fi
   if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
     AC_MSG_RESULT(failed)
 else  else
   AC_MSG_RESULT(no)    AC_MSG_RESULT(ok)
 fi  fi
 ])  ]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
   
   
 # AC_PATH_MAGIC - find a file program which can recognise a shared library  # AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME])
 AC_DEFUN([AC_PATH_MAGIC],  # ---------------------------------------
 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])dnl  AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC],
 AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin:$PATH)  [_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)=
 if test -z "$lt_cv_path_MAGIC_CMD"; then  _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
   if test -n "$ac_tool_prefix"; then  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)=
     AC_PATH_TOOL_PREFIX(file, /usr/bin:$PATH)  
   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'
         fi
         ;;
       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'
         ;;
       beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
         # 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
         fi
         ;;
       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    else
     MAGIC_CMD=:      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'
           fi
           ;;
         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
           ;;
          darwin*)
            # PIC is the default on this platform
            # Common symbols not allowed in MH_DYLIB files
            case $cc_basename in
              xlc*)
              _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
              _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
              ;;
            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 | dragonfly*)
           # 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'
               fi
               ;;
             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* | ecpc*)
               # 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'
               ;;
             pgCC*)
               # Portland Group C++ compiler.
               _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
               _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
               _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
               ;;
             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
   fi    fi
 fi  ],
 ])  [
     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
         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'
         fi
         ;;
   
 # AC_PROG_LD - find the path to the GNU or non-GNU linker      amigaos*)
 AC_DEFUN([AC_PROG_LD],        # FIXME: we need at least 68020 code to build shared libraries, but
 [AC_ARG_WITH(gnu-ld,        # adding the `-m68020' flag to GCC prevents building anything better,
 [  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],        # like `-m68040'.
 test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)        _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
 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  
   # 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