Changeset 4059


Ignore:
Timestamp:
Jan 16, 2020 1:49:57 AM (5 months ago)
Author:
stefan
Message:

cleanup base configure, remove config_glpk.h.in

  • no need for C compiler or libtool in base dir
  • no more use for config header
Location:
ThirdParty/Glpk/branches/autotools-update
Files:
1 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • ThirdParty/Glpk/branches/autotools-update/Makefile.in

    r4058 r4059  
    103103 configure.lineno config.status.lineno
    104104mkinstalldirs = $(install_sh) -d
    105 CONFIG_HEADER = config_glpk.h
    106105CONFIG_CLEAN_FILES = coinglpk.pc
    107106CONFIG_CLEAN_VPATH_FILES =
     
    169168AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
    170169        cscope
    171 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
    172         $(LISP)config_glpk.h.in
     170am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
    173171# Read a list of newline-separated strings from the standard input,
    174172# and print each of them once, without duplicates.  Input order is
     
    194192AMTAR = @AMTAR@
    195193AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
    196 AR = @AR@
    197 AS = @AS@
    198194AUTOCONF = @AUTOCONF@
    199195AUTOHEADER = @AUTOHEADER@
     
    201197AWK = @AWK@
    202198CC = @CC@
    203 CCDEPMODE = @CCDEPMODE@
    204 CFLAGS = @CFLAGS@
    205 CPP = @CPP@
    206 CPPFLAGS = @CPPFLAGS@
    207199CYGPATH_W = @CYGPATH_W@
    208200DEFS = @DEFS@
    209 DEPDIR = @DEPDIR@
    210 DLLTOOL = @DLLTOOL@
    211 DSYMUTIL = @DSYMUTIL@
    212 DUMPBIN = @DUMPBIN@
    213201ECHO_C = @ECHO_C@
    214202ECHO_N = @ECHO_N@
    215203ECHO_T = @ECHO_T@
    216 EGREP = @EGREP@
    217 EXEEXT = @EXEEXT@
    218 FGREP = @FGREP@
    219 GREP = @GREP@
    220204INSTALL = @INSTALL@
    221205INSTALL_DATA = @INSTALL_DATA@
     
    223207INSTALL_SCRIPT = @INSTALL_SCRIPT@
    224208INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
    225 LD = @LD@
    226 LDFLAGS = @LDFLAGS@
    227209LIBOBJS = @LIBOBJS@
    228210LIBS = @LIBS@
    229 LIBTOOL = @LIBTOOL@
    230 LIPO = @LIPO@
    231 LN_S = @LN_S@
    232211LTLIBOBJS = @LTLIBOBJS@
    233 LT_LDFLAGS = @LT_LDFLAGS@
    234 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
    235212MAINT = @MAINT@
    236213MAKEINFO = @MAKEINFO@
    237 MANIFEST_TOOL = @MANIFEST_TOOL@
    238214MKDIR_P = @MKDIR_P@
    239 NM = @NM@
    240 NMEDIT = @NMEDIT@
    241 OBJDUMP = @OBJDUMP@
    242 OBJEXT = @OBJEXT@
    243 OTOOL = @OTOOL@
    244 OTOOL64 = @OTOOL64@
    245215PACKAGE = @PACKAGE@
    246216PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
     
    251221PACKAGE_VERSION = @PACKAGE_VERSION@
    252222PATH_SEPARATOR = @PATH_SEPARATOR@
    253 RANLIB = @RANLIB@
    254 SED = @SED@
    255223SET_MAKE = @SET_MAKE@
    256224SHELL = @SHELL@
     
    261229abs_top_builddir = @abs_top_builddir@
    262230abs_top_srcdir = @abs_top_srcdir@
    263 ac_ct_AR = @ac_ct_AR@
    264 ac_ct_CC = @ac_ct_CC@
    265 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
    266 am__include = @am__include@
    267231am__leading_dot = @am__leading_dot@
    268 am__quote = @am__quote@
    269232am__tar = @am__tar@
    270233am__untar = @am__untar@
     
    316279# Setting SUBDIRS triggers automake to create the necessary recursion rules.
    317280SUBDIRS = @subdirs@
    318 all: config_glpk.h
    319         $(MAKE) $(AM_MAKEFLAGS) all-recursive
     281all: all-recursive
    320282
    321283.SUFFIXES:
     
    353315        $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
    354316$(am__aclocal_m4_deps):
    355 
    356 config_glpk.h: stamp-h1
    357         @test -f $@ || rm -f stamp-h1
    358         @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
    359 
    360 stamp-h1: $(srcdir)/config_glpk.h.in $(top_builddir)/config.status
    361         @rm -f stamp-h1
    362         cd $(top_builddir) && $(SHELL) ./config.status config_glpk.h
    363 $(srcdir)/config_glpk.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
    364         ($(am__cd) $(top_srcdir) && $(AUTOHEADER))
    365         rm -f stamp-h1
    366         touch $@
    367 
    368 distclean-hdr:
    369         -rm -f config_glpk.h stamp-h1
    370317coinglpk.pc: $(top_builddir)/config.status $(srcdir)/coinglpk.pc.in
    371318        cd $(top_builddir) && $(SHELL) ./config.status $@
    372 
    373 mostlyclean-libtool:
    374         -rm -f *.lo
    375 
    376 clean-libtool:
    377         -rm -rf .libs _libs
    378 
    379 distclean-libtool:
    380         -rm -f libtool config.lt
    381319install-pkgconfiglibDATA: $(pkgconfiglib_DATA)
    382320        @$(NORMAL_INSTALL)
     
    508446check-am: all-am
    509447check: check-recursive
    510 all-am: Makefile $(DATA) config_glpk.h
     448all-am: Makefile $(DATA)
    511449installdirs: installdirs-recursive
    512450installdirs-am:
     
    546484clean: clean-recursive
    547485
    548 clean-am: clean-generic clean-libtool mostlyclean-am
     486clean-am: clean-generic mostlyclean-am
    549487
    550488distclean: distclean-recursive
    551489        -rm -f $(am__CONFIG_DISTCLEAN_FILES)
    552490        -rm -f Makefile
    553 distclean-am: clean-am distclean-generic distclean-hdr \
    554         distclean-libtool distclean-tags
     491distclean-am: clean-am distclean-generic distclean-tags
    555492
    556493dvi: dvi-recursive
     
    602539mostlyclean: mostlyclean-recursive
    603540
    604 mostlyclean-am: mostlyclean-generic mostlyclean-libtool
     541mostlyclean-am: mostlyclean-generic
    605542
    606543pdf: pdf-recursive
     
    614551uninstall-am: uninstall-pkgconfiglibDATA
    615552
    616 .MAKE: $(am__recursive_targets) all install-am install-strip
     553.MAKE: $(am__recursive_targets) install-am install-strip
    617554
    618555.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
    619556        am--refresh check check-am clean clean-cscope clean-generic \
    620         clean-libtool cscope cscopelist-am ctags ctags-am distclean \
    621         distclean-generic distclean-hdr distclean-libtool \
    622         distclean-tags dvi dvi-am html html-am info info-am install \
    623         install-am install-data install-data-am install-dvi \
    624         install-dvi-am install-exec install-exec-am install-html \
    625         install-html-am install-info install-info-am install-man \
    626         install-pdf install-pdf-am install-pkgconfiglibDATA install-ps \
    627         install-ps-am install-strip installcheck installcheck-am \
    628         installdirs installdirs-am maintainer-clean \
    629         maintainer-clean-generic mostlyclean mostlyclean-generic \
    630         mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
    631         uninstall-am uninstall-pkgconfiglibDATA
     557        cscope cscopelist-am ctags ctags-am distclean \
     558        distclean-generic distclean-tags dvi dvi-am html html-am info \
     559        info-am install install-am install-data install-data-am \
     560        install-dvi install-dvi-am install-exec install-exec-am \
     561        install-html install-html-am install-info install-info-am \
     562        install-man install-pdf install-pdf-am \
     563        install-pkgconfiglibDATA install-ps install-ps-am \
     564        install-strip installcheck installcheck-am installdirs \
     565        installdirs-am maintainer-clean maintainer-clean-generic \
     566        mostlyclean mostlyclean-generic pdf pdf-am ps ps-am tags \
     567        tags-am uninstall uninstall-am uninstall-pkgconfiglibDATA
    632568
    633569.PRECIOUS: Makefile
  • ThirdParty/Glpk/branches/autotools-update/configure

    r4056 r4059  
    204204  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
    205205  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
    206   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
    207 
    208   test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
    209     ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    210     ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
    211     ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
    212     PATH=/empty FPATH=/empty; export PATH FPATH
    213     test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
    214       || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1
    215 test \$(( 1 + 1 )) = 2 || exit 1"
     206  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
    216207  if (eval "$as_required") 2>/dev/null; then :
    217208  as_have_required=yes
     
    571562as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
    572563
    573 SHELL=${CONFIG_SHELL-/bin/sh}
    574 
    575564
    576565test -n "$DJDIR" || exec 7<&0 </dev/null
     
    603592
    604593ac_unique_file="glpk/src/glpk.h"
    605 # Factoring default headers for most tests.
    606 ac_includes_default="\
    607 #include <stdio.h>
    608 #ifdef HAVE_SYS_TYPES_H
    609 # include <sys/types.h>
    610 #endif
    611 #ifdef HAVE_SYS_STAT_H
    612 # include <sys/stat.h>
    613 #endif
    614 #ifdef STDC_HEADERS
    615 # include <stdlib.h>
    616 # include <stddef.h>
    617 #else
    618 # ifdef HAVE_STDLIB_H
    619 #  include <stdlib.h>
    620 # endif
    621 #endif
    622 #ifdef HAVE_STRING_H
    623 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
    624 #  include <memory.h>
    625 # endif
    626 # include <string.h>
    627 #endif
    628 #ifdef HAVE_STRINGS_H
    629 # include <strings.h>
    630 #endif
    631 #ifdef HAVE_INTTYPES_H
    632 # include <inttypes.h>
    633 #endif
    634 #ifdef HAVE_STDINT_H
    635 # include <stdint.h>
    636 #endif
    637 #ifdef HAVE_UNISTD_H
    638 # include <unistd.h>
    639 #endif"
    640 
    641594enable_option_checking=no
    642 ac_subst_vars='am__EXEEXT_FALSE
    643 am__EXEEXT_TRUE
    644 LTLIBOBJS
     595ac_subst_vars='LTLIBOBJS
    645596LIBOBJS
    646597subdirs
    647 LT_LDFLAGS
    648 CPP
    649 LT_SYS_LIBRARY_PATH
    650 OTOOL64
    651 OTOOL
    652 LIPO
    653 NMEDIT
    654 DSYMUTIL
    655 MANIFEST_TOOL
    656 RANLIB
    657 ac_ct_AR
    658 AR
    659 LN_S
    660 NM
    661 ac_ct_DUMPBIN
    662 DUMPBIN
    663 LD
    664 FGREP
    665 EGREP
    666 GREP
    667 SED
    668 LIBTOOL
    669 OBJDUMP
    670 DLLTOOL
    671 AS
    672 am__fastdepCC_FALSE
    673 am__fastdepCC_TRUE
    674 CCDEPMODE
    675 am__nodep
    676 AMDEPBACKSLASH
    677 AMDEP_FALSE
    678 AMDEP_TRUE
    679 am__include
    680 DEPDIR
    681 OBJEXT
    682 EXEEXT
    683 ac_ct_CC
    684 CPPFLAGS
    685 LDFLAGS
    686 CFLAGS
    687598MAINT
    688599MAINTAINER_MODE_FALSE
     
    763674PACKAGE_NAME
    764675PATH_SEPARATOR
    765 SHELL
    766 am__quote'
     676SHELL'
    767677ac_subst_files=''
    768678ac_user_opts='
     
    772682enable_silent_rules
    773683enable_maintainer_mode
    774 enable_dependency_tracking
    775 enable_static
    776 with_pic
    777 enable_shared
    778 enable_fast_install
    779 with_aix_soname
    780 with_gnu_ld
    781 with_sysroot
    782 enable_libtool_lock
    783684'
    784685      ac_precious_vars='build_alias
    785686host_alias
    786 target_alias
    787 CC
    788 CFLAGS
    789 LDFLAGS
    790 LIBS
    791 CPPFLAGS
    792 LT_SYS_LIBRARY_PATH
    793 CPP'
     687target_alias'
    794688ac_subdirs_all='glpk'
    795689
     
    14191313                          enable make rules and dependencies not useful (and
    14201314                          sometimes confusing) to the casual installer
    1421   --enable-dependency-tracking
    1422                           do not reject slow dependency extractors
    1423   --disable-dependency-tracking
    1424                           speeds up one-time build
    1425   --enable-static[=PKGS]  build static libraries [default=no]
    1426   --enable-shared[=PKGS]  build shared libraries [default=yes]
    1427   --enable-fast-install[=PKGS]
    1428                           optimize for fast installation [default=yes]
    1429   --disable-libtool-lock  avoid locking (might break parallel builds)
    1430 
    1431 Optional Packages:
    1432   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
    1433   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
    1434   --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
    1435                           both]
    1436   --with-aix-soname=aix|svr4|both
    1437                           shared library versioning (aka "SONAME") variant to
    1438                           provide on AIX, [default=aix].
    1439   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
    1440   --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
    1441                           compiler's sysroot if not specified).
    1442 
    1443 Some influential environment variables:
    1444   CC          C compiler command
    1445   CFLAGS      C compiler flags
    1446   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
    1447               nonstandard directory <lib dir>
    1448   LIBS        libraries to pass to the linker, e.g. -l<library>
    1449   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
    1450               you have headers in a nonstandard directory <include dir>
    1451   LT_SYS_LIBRARY_PATH
    1452               User-defined run-time library search path.
    1453   CPP         C preprocessor
    1454 
    1455 Use these variables to override the choices made by `configure' or to help
    1456 it to find libraries and programs with nonstandard names/locations.
    14571315
    14581316Report bugs to <http://projects.coin-or.org/BuildTools/newticket>.
     
    15391397## Autoconf initialization. ##
    15401398## ------------------------ ##
    1541 
    1542 # ac_fn_c_try_compile LINENO
    1543 # --------------------------
    1544 # Try to compile conftest.$ac_ext, and return whether this succeeded.
    1545 ac_fn_c_try_compile ()
    1546 {
    1547   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1548   rm -f conftest.$ac_objext
    1549   if { { ac_try="$ac_compile"
    1550 case "(($ac_try" in
    1551   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1552   *) ac_try_echo=$ac_try;;
    1553 esac
    1554 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1555 $as_echo "$ac_try_echo"; } >&5
    1556   (eval "$ac_compile") 2>conftest.err
    1557   ac_status=$?
    1558   if test -s conftest.err; then
    1559     grep -v '^ *+' conftest.err >conftest.er1
    1560     cat conftest.er1 >&5
    1561     mv -f conftest.er1 conftest.err
    1562   fi
    1563   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1564   test $ac_status = 0; } && {
    1565          test -z "$ac_c_werror_flag" ||
    1566          test ! -s conftest.err
    1567        } && test -s conftest.$ac_objext; then :
    1568   ac_retval=0
    1569 else
    1570   $as_echo "$as_me: failed program was:" >&5
    1571 sed 's/^/| /' conftest.$ac_ext >&5
    1572 
    1573         ac_retval=1
    1574 fi
    1575   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1576   as_fn_set_status $ac_retval
    1577 
    1578 } # ac_fn_c_try_compile
    1579 
    1580 # ac_fn_c_try_link LINENO
    1581 # -----------------------
    1582 # Try to link conftest.$ac_ext, and return whether this succeeded.
    1583 ac_fn_c_try_link ()
    1584 {
    1585   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1586   rm -f conftest.$ac_objext conftest$ac_exeext
    1587   if { { ac_try="$ac_link"
    1588 case "(($ac_try" in
    1589   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1590   *) ac_try_echo=$ac_try;;
    1591 esac
    1592 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1593 $as_echo "$ac_try_echo"; } >&5
    1594   (eval "$ac_link") 2>conftest.err
    1595   ac_status=$?
    1596   if test -s conftest.err; then
    1597     grep -v '^ *+' conftest.err >conftest.er1
    1598     cat conftest.er1 >&5
    1599     mv -f conftest.er1 conftest.err
    1600   fi
    1601   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1602   test $ac_status = 0; } && {
    1603          test -z "$ac_c_werror_flag" ||
    1604          test ! -s conftest.err
    1605        } && test -s conftest$ac_exeext && {
    1606          test "$cross_compiling" = yes ||
    1607          test -x conftest$ac_exeext
    1608        }; then :
    1609   ac_retval=0
    1610 else
    1611   $as_echo "$as_me: failed program was:" >&5
    1612 sed 's/^/| /' conftest.$ac_ext >&5
    1613 
    1614         ac_retval=1
    1615 fi
    1616   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
    1617   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
    1618   # interfere with the next link command; also delete a directory that is
    1619   # left behind by Apple's compiler.  We do this before executing the actions.
    1620   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
    1621   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1622   as_fn_set_status $ac_retval
    1623 
    1624 } # ac_fn_c_try_link
    1625 
    1626 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
    1627 # -------------------------------------------------------
    1628 # Tests whether HEADER exists and can be compiled using the include files in
    1629 # INCLUDES, setting the cache variable VAR accordingly.
    1630 ac_fn_c_check_header_compile ()
    1631 {
    1632   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1633   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
    1634 $as_echo_n "checking for $2... " >&6; }
    1635 if eval \${$3+:} false; then :
    1636   $as_echo_n "(cached) " >&6
    1637 else
    1638   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    1639 /* end confdefs.h.  */
    1640 $4
    1641 #include <$2>
    1642 _ACEOF
    1643 if ac_fn_c_try_compile "$LINENO"; then :
    1644   eval "$3=yes"
    1645 else
    1646   eval "$3=no"
    1647 fi
    1648 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    1649 fi
    1650 eval ac_res=\$$3
    1651                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
    1652 $as_echo "$ac_res" >&6; }
    1653   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1654 
    1655 } # ac_fn_c_check_header_compile
    1656 
    1657 # ac_fn_c_try_cpp LINENO
    1658 # ----------------------
    1659 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
    1660 ac_fn_c_try_cpp ()
    1661 {
    1662   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1663   if { { ac_try="$ac_cpp conftest.$ac_ext"
    1664 case "(($ac_try" in
    1665   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1666   *) ac_try_echo=$ac_try;;
    1667 esac
    1668 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1669 $as_echo "$ac_try_echo"; } >&5
    1670   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
    1671   ac_status=$?
    1672   if test -s conftest.err; then
    1673     grep -v '^ *+' conftest.err >conftest.er1
    1674     cat conftest.er1 >&5
    1675     mv -f conftest.er1 conftest.err
    1676   fi
    1677   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1678   test $ac_status = 0; } > conftest.i && {
    1679          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
    1680          test ! -s conftest.err
    1681        }; then :
    1682   ac_retval=0
    1683 else
    1684   $as_echo "$as_me: failed program was:" >&5
    1685 sed 's/^/| /' conftest.$ac_ext >&5
    1686 
    1687     ac_retval=1
    1688 fi
    1689   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1690   as_fn_set_status $ac_retval
    1691 
    1692 } # ac_fn_c_try_cpp
    1693 
    1694 # ac_fn_c_try_run LINENO
    1695 # ----------------------
    1696 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
    1697 # that executables *can* be run.
    1698 ac_fn_c_try_run ()
    1699 {
    1700   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1701   if { { ac_try="$ac_link"
    1702 case "(($ac_try" in
    1703   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1704   *) ac_try_echo=$ac_try;;
    1705 esac
    1706 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1707 $as_echo "$ac_try_echo"; } >&5
    1708   (eval "$ac_link") 2>&5
    1709   ac_status=$?
    1710   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1711   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
    1712   { { case "(($ac_try" in
    1713   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1714   *) ac_try_echo=$ac_try;;
    1715 esac
    1716 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1717 $as_echo "$ac_try_echo"; } >&5
    1718   (eval "$ac_try") 2>&5
    1719   ac_status=$?
    1720   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1721   test $ac_status = 0; }; }; then :
    1722   ac_retval=0
    1723 else
    1724   $as_echo "$as_me: program exited with status $ac_status" >&5
    1725        $as_echo "$as_me: failed program was:" >&5
    1726 sed 's/^/| /' conftest.$ac_ext >&5
    1727 
    1728        ac_retval=$ac_status
    1729 fi
    1730   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
    1731   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1732   as_fn_set_status $ac_retval
    1733 
    1734 } # ac_fn_c_try_run
    1735 
    1736 # ac_fn_c_check_func LINENO FUNC VAR
    1737 # ----------------------------------
    1738 # Tests whether FUNC exists, setting the cache variable VAR accordingly
    1739 ac_fn_c_check_func ()
    1740 {
    1741   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1742   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
    1743 $as_echo_n "checking for $2... " >&6; }
    1744 if eval \${$3+:} false; then :
    1745   $as_echo_n "(cached) " >&6
    1746 else
    1747   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    1748 /* end confdefs.h.  */
    1749 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
    1750    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
    1751 #define $2 innocuous_$2
    1752 
    1753 /* System header to define __stub macros and hopefully few prototypes,
    1754     which can conflict with char $2 (); below.
    1755     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    1756     <limits.h> exists even on freestanding compilers.  */
    1757 
    1758 #ifdef __STDC__
    1759 # include <limits.h>
    1760 #else
    1761 # include <assert.h>
    1762 #endif
    1763 
    1764 #undef $2
    1765 
    1766 /* Override any GCC internal prototype to avoid an error.
    1767    Use char because int might match the return type of a GCC
    1768    builtin and then its argument prototype would still apply.  */
    1769 #ifdef __cplusplus
    1770 extern "C"
    1771 #endif
    1772 char $2 ();
    1773 /* The GNU C library defines this for functions which it implements
    1774     to always fail with ENOSYS.  Some functions are actually named
    1775     something starting with __ and the normal name is an alias.  */
    1776 #if defined __stub_$2 || defined __stub___$2
    1777 choke me
    1778 #endif
    1779 
    1780 int
    1781 main ()
    1782 {
    1783 return $2 ();
    1784   ;
    1785   return 0;
    1786 }
    1787 _ACEOF
    1788 if ac_fn_c_try_link "$LINENO"; then :
    1789   eval "$3=yes"
    1790 else
    1791   eval "$3=no"
    1792 fi
    1793 rm -f core conftest.err conftest.$ac_objext \
    1794     conftest$ac_exeext conftest.$ac_ext
    1795 fi
    1796 eval ac_res=\$$3
    1797                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
    1798 $as_echo "$ac_res" >&6; }
    1799   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1800 
    1801 } # ac_fn_c_check_func
    18021399cat >config.log <<_ACEOF
    18031400This file contains any messages produced by compilers while
     
    30832680#############################################################################
    30842681
    3085 # Get the name of the C compiler and appropriate compiler options.
    3086 
    3087 DEPDIR="${am__leading_dot}deps"
    3088 
    3089 ac_config_commands="$ac_config_commands depfiles"
    3090 
    3091 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
    3092 $as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
    3093 cat > confinc.mk << 'END'
    3094 am__doit:
    3095         @echo this is the am__doit target >confinc.out
    3096 .PHONY: am__doit
    3097 END
    3098 am__include="#"
    3099 am__quote=
    3100 # BSD make does it like this.
    3101 echo '.include "confinc.mk" # ignored' > confmf.BSD
    3102 # Other make implementations (GNU, Solaris 10, AIX) do it like this.
    3103 echo 'include confinc.mk # ignored' > confmf.GNU
    3104 _am_result=no
    3105 for s in GNU BSD; do
    3106   { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
    3107    (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
    3108    ac_status=$?
    3109    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    3110    (exit $ac_status); }
    3111   case $?:`cat confinc.out 2>/dev/null` in #(
    3112   '0:this is the am__doit target') :
    3113     case $s in #(
    3114   BSD) :
    3115     am__include='.include' am__quote='"' ;; #(
    3116   *) :
    3117     am__include='include' am__quote='' ;;
    3118 esac ;; #(
    3119   *) :
    3120      ;;
    3121 esac
    3122   if test "$am__include" != "#"; then
    3123     _am_result="yes ($s style)"
    3124     break
    3125   fi
    3126 done
    3127 rm -f confinc.* confmf.*
    3128 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
    3129 $as_echo "${_am_result}" >&6; }
    3130 
    3131 # Check whether --enable-dependency-tracking was given.
    3132 if test "${enable_dependency_tracking+set}" = set; then :
    3133   enableval=$enable_dependency_tracking;
    3134 fi
    3135 
    3136 if test "x$enable_dependency_tracking" != xno; then
    3137   am_depcomp="$ac_aux_dir/depcomp"
    3138   AMDEPBACKSLASH='\'
    3139   am__nodep='_no'
    3140 fi
    3141  if test "x$enable_dependency_tracking" != xno; then
    3142   AMDEP_TRUE=
    3143   AMDEP_FALSE='#'
    3144 else
    3145   AMDEP_TRUE='#'
    3146   AMDEP_FALSE=
    3147 fi
    3148 
    3149 
    3150 
    3151 
    3152 
    3153   # Setting up libtool with LT_INIT will AC_REQUIRE AC_PROG_CC, but we want
    3154   # to invoke it from this macro first so that we can supply a parameter.
    3155 
    3156 
    3157   # If enable-msvc, then test for Intel (on Windows) and MS C compiler
    3158   # explicitly and add the compile wrapper before AC_PROG_CC. The compile
    3159   # wrapper works around issues related to finding MS link.exe. (Unix link.exe
    3160   # occurs first in PATH, which causes compile and link checks to fail.) For
    3161   # the same reason, set LD to use the compile wrapper. If CC remains unset
    3162   # (neither icl or cl was found, and CC was not set by the user), stop with
    3163   # an error.
    3164 
    3165   if test $enable_msvc = yes ; then
    3166     for ac_prog in icl cl
    3167 do
    3168   # Extract the first word of "$ac_prog", so it can be a program name with args.
    3169 set dummy $ac_prog; ac_word=$2
    3170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3171 $as_echo_n "checking for $ac_word... " >&6; }
    3172 if ${ac_cv_prog_CC+:} false; then :
    3173   $as_echo_n "(cached) " >&6
    3174 else
    3175   if test -n "$CC"; then
    3176   ac_cv_prog_CC="$CC" # Let the user override the test.
    3177 else
    3178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3179 for as_dir in $PATH
    3180 do
    3181   IFS=$as_save_IFS
    3182   test -z "$as_dir" && as_dir=.
    3183     for ac_exec_ext in '' $ac_executable_extensions; do
    3184   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3185     ac_cv_prog_CC="$ac_prog"
    3186     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3187     break 2
    3188   fi
    3189 done
    3190   done
    3191 IFS=$as_save_IFS
    3192 
    3193 fi
    3194 fi
    3195 CC=$ac_cv_prog_CC
    3196 if test -n "$CC"; then
    3197   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    3198 $as_echo "$CC" >&6; }
    3199 else
    3200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3201 $as_echo "no" >&6; }
    3202 fi
    3203 
    3204 
    3205   test -n "$CC" && break
    3206 done
    3207 
    3208     if test -n "$CC" ; then
    3209       CC="$am_aux_dir/compile $CC"
    3210       ac_cv_prog_CC="$CC"
    3211       LD="$CC"
    3212     else
    3213       as_fn_error $? "Neither MS nor Intel C compiler found in PATH and CC is unset." "$LINENO" 5
    3214     fi
    3215   fi
    3216 
    3217   # Look for some C compiler and check that it works. If the user has set CC
    3218   # or we found icl/cl above, this shouldn't overwrite CC. Unlike the macros
    3219   # that establish C++ or Fortran compilers, PROG_CC also takes care of adding
    3220   # the compile wrapper if needed.
    3221 
    3222   ac_ext=c
    3223 ac_cpp='$CPP $CPPFLAGS'
    3224 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    3225 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    3226 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    3227 if test -n "$ac_tool_prefix"; then
    3228   for ac_prog in gcc clang cc icc icl cl cc xlc xlc_r pgcc
    3229   do
    3230     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    3231 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    3232 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3233 $as_echo_n "checking for $ac_word... " >&6; }
    3234 if ${ac_cv_prog_CC+:} false; then :
    3235   $as_echo_n "(cached) " >&6
    3236 else
    3237   if test -n "$CC"; then
    3238   ac_cv_prog_CC="$CC" # Let the user override the test.
    3239 else
    3240 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3241 for as_dir in $PATH
    3242 do
    3243   IFS=$as_save_IFS
    3244   test -z "$as_dir" && as_dir=.
    3245     for ac_exec_ext in '' $ac_executable_extensions; do
    3246   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3247     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    3248     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3249     break 2
    3250   fi
    3251 done
    3252   done
    3253 IFS=$as_save_IFS
    3254 
    3255 fi
    3256 fi
    3257 CC=$ac_cv_prog_CC
    3258 if test -n "$CC"; then
    3259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    3260 $as_echo "$CC" >&6; }
    3261 else
    3262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3263 $as_echo "no" >&6; }
    3264 fi
    3265 
    3266 
    3267     test -n "$CC" && break
    3268   done
    3269 fi
    3270 if test -z "$CC"; then
    3271   ac_ct_CC=$CC
    3272   for ac_prog in gcc clang cc icc icl cl cc xlc xlc_r pgcc
    3273 do
    3274   # Extract the first word of "$ac_prog", so it can be a program name with args.
    3275 set dummy $ac_prog; ac_word=$2
    3276 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3277 $as_echo_n "checking for $ac_word... " >&6; }
    3278 if ${ac_cv_prog_ac_ct_CC+:} false; then :
    3279   $as_echo_n "(cached) " >&6
    3280 else
    3281   if test -n "$ac_ct_CC"; then
    3282   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
    3283 else
    3284 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3285 for as_dir in $PATH
    3286 do
    3287   IFS=$as_save_IFS
    3288   test -z "$as_dir" && as_dir=.
    3289     for ac_exec_ext in '' $ac_executable_extensions; do
    3290   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3291     ac_cv_prog_ac_ct_CC="$ac_prog"
    3292     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3293     break 2
    3294   fi
    3295 done
    3296   done
    3297 IFS=$as_save_IFS
    3298 
    3299 fi
    3300 fi
    3301 ac_ct_CC=$ac_cv_prog_ac_ct_CC
    3302 if test -n "$ac_ct_CC"; then
    3303   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
    3304 $as_echo "$ac_ct_CC" >&6; }
    3305 else
    3306   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3307 $as_echo "no" >&6; }
    3308 fi
    3309 
    3310 
    3311   test -n "$ac_ct_CC" && break
    3312 done
    3313 
    3314   if test "x$ac_ct_CC" = x; then
    3315     CC=""
    3316   else
    3317     case $cross_compiling:$ac_tool_warned in
    3318 yes:)
    3319 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    3320 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    3321 ac_tool_warned=yes ;;
    3322 esac
    3323     CC=$ac_ct_CC
    3324   fi
    3325 fi
    3326 
    3327 
    3328 test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    3329 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    3330 as_fn_error $? "no acceptable C compiler found in \$PATH
    3331 See \`config.log' for more details" "$LINENO" 5; }
    3332 
    3333 # Provide some information about the compiler.
    3334 $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
    3335 set X $ac_compile
    3336 ac_compiler=$2
    3337 for ac_option in --version -v -V -qversion; do
    3338   { { ac_try="$ac_compiler $ac_option >&5"
    3339 case "(($ac_try" in
    3340   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    3341   *) ac_try_echo=$ac_try;;
    3342 esac
    3343 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    3344 $as_echo "$ac_try_echo"; } >&5
    3345   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
    3346   ac_status=$?
    3347   if test -s conftest.err; then
    3348     sed '10a\
    3349 ... rest of stderr output deleted ...
    3350          10q' conftest.err >conftest.er1
    3351     cat conftest.er1 >&5
    3352   fi
    3353   rm -f conftest.er1 conftest.err
    3354   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    3355   test $ac_status = 0; }
    3356 done
    3357 
    3358 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3359 /* end confdefs.h.  */
    3360 
    3361 int
    3362 main ()
    3363 {
    3364 
    3365   ;
    3366   return 0;
    3367 }
    3368 _ACEOF
    3369 ac_clean_files_save=$ac_clean_files
    3370 ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
    3371 # Try to create an executable without -o first, disregard a.out.
    3372 # It will help us diagnose broken compilers, and finding out an intuition
    3373 # of exeext.
    3374 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
    3375 $as_echo_n "checking whether the C compiler works... " >&6; }
    3376 ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
    3377 
    3378 # The possible output files:
    3379 ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
    3380 
    3381 ac_rmfiles=
    3382 for ac_file in $ac_files
    3383 do
    3384   case $ac_file in
    3385     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    3386     * ) ac_rmfiles="$ac_rmfiles $ac_file";;
    3387   esac
    3388 done
    3389 rm -f $ac_rmfiles
    3390 
    3391 if { { ac_try="$ac_link_default"
    3392 case "(($ac_try" in
    3393   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    3394   *) ac_try_echo=$ac_try;;
    3395 esac
    3396 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    3397 $as_echo "$ac_try_echo"; } >&5
    3398   (eval "$ac_link_default") 2>&5
    3399   ac_status=$?
    3400   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    3401   test $ac_status = 0; }; then :
    3402   # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
    3403 # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
    3404 # in a Makefile.  We should not override ac_cv_exeext if it was cached,
    3405 # so that the user can short-circuit this test for compilers unknown to
    3406 # Autoconf.
    3407 for ac_file in $ac_files ''
    3408 do
    3409   test -f "$ac_file" || continue
    3410   case $ac_file in
    3411     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
    3412         ;;
    3413     [ab].out )
    3414         # We found the default executable, but exeext='' is most
    3415         # certainly right.
    3416         break;;
    3417     *.* )
    3418         if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
    3419         then :; else
    3420            ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
    3421         fi
    3422         # We set ac_cv_exeext here because the later test for it is not
    3423         # safe: cross compilers may not add the suffix if given an `-o'
    3424         # argument, so we may need to know it at that point already.
    3425         # Even if this section looks crufty: it has the advantage of
    3426         # actually working.
    3427         break;;
    3428     * )
    3429         break;;
    3430   esac
    3431 done
    3432 test "$ac_cv_exeext" = no && ac_cv_exeext=
    3433 
    3434 else
    3435   ac_file=''
    3436 fi
    3437 if test -z "$ac_file"; then :
    3438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3439 $as_echo "no" >&6; }
    3440 $as_echo "$as_me: failed program was:" >&5
    3441 sed 's/^/| /' conftest.$ac_ext >&5
    3442 
    3443 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    3444 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    3445 as_fn_error 77 "C compiler cannot create executables
    3446 See \`config.log' for more details" "$LINENO" 5; }
    3447 else
    3448   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
    3449 $as_echo "yes" >&6; }
    3450 fi
    3451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
    3452 $as_echo_n "checking for C compiler default output file name... " >&6; }
    3453 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
    3454 $as_echo "$ac_file" >&6; }
    3455 ac_exeext=$ac_cv_exeext
    3456 
    3457 rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
    3458 ac_clean_files=$ac_clean_files_save
    3459 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
    3460 $as_echo_n "checking for suffix of executables... " >&6; }
    3461 if { { ac_try="$ac_link"
    3462 case "(($ac_try" in
    3463   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    3464   *) ac_try_echo=$ac_try;;
    3465 esac
    3466 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    3467 $as_echo "$ac_try_echo"; } >&5
    3468   (eval "$ac_link") 2>&5
    3469   ac_status=$?
    3470   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    3471   test $ac_status = 0; }; then :
    3472   # If both `conftest.exe' and `conftest' are `present' (well, observable)
    3473 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
    3474 # work properly (i.e., refer to `conftest.exe'), while it won't with
    3475 # `rm'.
    3476 for ac_file in conftest.exe conftest conftest.*; do
    3477   test -f "$ac_file" || continue
    3478   case $ac_file in
    3479     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    3480     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
    3481           break;;
    3482     * ) break;;
    3483   esac
    3484 done
    3485 else
    3486   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    3487 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    3488 as_fn_error $? "cannot compute suffix of executables: cannot compile and link
    3489 See \`config.log' for more details" "$LINENO" 5; }
    3490 fi
    3491 rm -f conftest conftest$ac_cv_exeext
    3492 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
    3493 $as_echo "$ac_cv_exeext" >&6; }
    3494 
    3495 rm -f conftest.$ac_ext
    3496 EXEEXT=$ac_cv_exeext
    3497 ac_exeext=$EXEEXT
    3498 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3499 /* end confdefs.h.  */
    3500 #include <stdio.h>
    3501 int
    3502 main ()
    3503 {
    3504 FILE *f = fopen ("conftest.out", "w");
    3505  return ferror (f) || fclose (f) != 0;
    3506 
    3507   ;
    3508   return 0;
    3509 }
    3510 _ACEOF
    3511 ac_clean_files="$ac_clean_files conftest.out"
    3512 # Check that the compiler produces executables we can run.  If not, either
    3513 # the compiler is broken, or we cross compile.
    3514 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
    3515 $as_echo_n "checking whether we are cross compiling... " >&6; }
    3516 if test "$cross_compiling" != yes; then
    3517   { { ac_try="$ac_link"
    3518 case "(($ac_try" in
    3519   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    3520   *) ac_try_echo=$ac_try;;
    3521 esac
    3522 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    3523 $as_echo "$ac_try_echo"; } >&5
    3524   (eval "$ac_link") 2>&5
    3525   ac_status=$?
    3526   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    3527   test $ac_status = 0; }
    3528   if { ac_try='./conftest$ac_cv_exeext'
    3529   { { case "(($ac_try" in
    3530   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    3531   *) ac_try_echo=$ac_try;;
    3532 esac
    3533 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    3534 $as_echo "$ac_try_echo"; } >&5
    3535   (eval "$ac_try") 2>&5
    3536   ac_status=$?
    3537   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    3538   test $ac_status = 0; }; }; then
    3539     cross_compiling=no
    3540   else
    3541     if test "$cross_compiling" = maybe; then
    3542         cross_compiling=yes
    3543     else
    3544         { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    3545 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    3546 as_fn_error $? "cannot run C compiled programs.
    3547 If you meant to cross compile, use \`--host'.
    3548 See \`config.log' for more details" "$LINENO" 5; }
    3549     fi
    3550   fi
    3551 fi
    3552 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
    3553 $as_echo "$cross_compiling" >&6; }
    3554 
    3555 rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
    3556 ac_clean_files=$ac_clean_files_save
    3557 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
    3558 $as_echo_n "checking for suffix of object files... " >&6; }
    3559 if ${ac_cv_objext+:} false; then :
    3560   $as_echo_n "(cached) " >&6
    3561 else
    3562   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3563 /* end confdefs.h.  */
    3564 
    3565 int
    3566 main ()
    3567 {
    3568 
    3569   ;
    3570   return 0;
    3571 }
    3572 _ACEOF
    3573 rm -f conftest.o conftest.obj
    3574 if { { ac_try="$ac_compile"
    3575 case "(($ac_try" in
    3576   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    3577   *) ac_try_echo=$ac_try;;
    3578 esac
    3579 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    3580 $as_echo "$ac_try_echo"; } >&5
    3581   (eval "$ac_compile") 2>&5
    3582   ac_status=$?
    3583   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    3584   test $ac_status = 0; }; then :
    3585   for ac_file in conftest.o conftest.obj conftest.*; do
    3586   test -f "$ac_file" || continue;
    3587   case $ac_file in
    3588     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
    3589     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
    3590        break;;
    3591   esac
    3592 done
    3593 else
    3594   $as_echo "$as_me: failed program was:" >&5
    3595 sed 's/^/| /' conftest.$ac_ext >&5
    3596 
    3597 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    3598 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    3599 as_fn_error $? "cannot compute suffix of object files: cannot compile
    3600 See \`config.log' for more details" "$LINENO" 5; }
    3601 fi
    3602 rm -f conftest.$ac_cv_objext conftest.$ac_ext
    3603 fi
    3604 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
    3605 $as_echo "$ac_cv_objext" >&6; }
    3606 OBJEXT=$ac_cv_objext
    3607 ac_objext=$OBJEXT
    3608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
    3609 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
    3610 if ${ac_cv_c_compiler_gnu+:} false; then :
    3611   $as_echo_n "(cached) " >&6
    3612 else
    3613   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3614 /* end confdefs.h.  */
    3615 
    3616 int
    3617 main ()
    3618 {
    3619 #ifndef __GNUC__
    3620        choke me
    3621 #endif
    3622 
    3623   ;
    3624   return 0;
    3625 }
    3626 _ACEOF
    3627 if ac_fn_c_try_compile "$LINENO"; then :
    3628   ac_compiler_gnu=yes
    3629 else
    3630   ac_compiler_gnu=no
    3631 fi
    3632 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    3633 ac_cv_c_compiler_gnu=$ac_compiler_gnu
    3634 
    3635 fi
    3636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
    3637 $as_echo "$ac_cv_c_compiler_gnu" >&6; }
    3638 if test $ac_compiler_gnu = yes; then
    3639   GCC=yes
    3640 else
    3641   GCC=
    3642 fi
    3643 ac_test_CFLAGS=${CFLAGS+set}
    3644 ac_save_CFLAGS=$CFLAGS
    3645 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
    3646 $as_echo_n "checking whether $CC accepts -g... " >&6; }
    3647 if ${ac_cv_prog_cc_g+:} false; then :
    3648   $as_echo_n "(cached) " >&6
    3649 else
    3650   ac_save_c_werror_flag=$ac_c_werror_flag
    3651    ac_c_werror_flag=yes
    3652    ac_cv_prog_cc_g=no
    3653    CFLAGS="-g"
    3654    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3655 /* end confdefs.h.  */
    3656 
    3657 int
    3658 main ()
    3659 {
    3660 
    3661   ;
    3662   return 0;
    3663 }
    3664 _ACEOF
    3665 if ac_fn_c_try_compile "$LINENO"; then :
    3666   ac_cv_prog_cc_g=yes
    3667 else
    3668   CFLAGS=""
    3669       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3670 /* end confdefs.h.  */
    3671 
    3672 int
    3673 main ()
    3674 {
    3675 
    3676   ;
    3677   return 0;
    3678 }
    3679 _ACEOF
    3680 if ac_fn_c_try_compile "$LINENO"; then :
    3681 
    3682 else
    3683   ac_c_werror_flag=$ac_save_c_werror_flag
    3684          CFLAGS="-g"
    3685          cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3686 /* end confdefs.h.  */
    3687 
    3688 int
    3689 main ()
    3690 {
    3691 
    3692   ;
    3693   return 0;
    3694 }
    3695 _ACEOF
    3696 if ac_fn_c_try_compile "$LINENO"; then :
    3697   ac_cv_prog_cc_g=yes
    3698 fi
    3699 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    3700 fi
    3701 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    3702 fi
    3703 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    3704    ac_c_werror_flag=$ac_save_c_werror_flag
    3705 fi
    3706 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
    3707 $as_echo "$ac_cv_prog_cc_g" >&6; }
    3708 if test "$ac_test_CFLAGS" = set; then
    3709   CFLAGS=$ac_save_CFLAGS
    3710 elif test $ac_cv_prog_cc_g = yes; then
    3711   if test "$GCC" = yes; then
    3712     CFLAGS="-g -O2"
    3713   else
    3714     CFLAGS="-g"
    3715   fi
    3716 else
    3717   if test "$GCC" = yes; then
    3718     CFLAGS="-O2"
    3719   else
    3720     CFLAGS=
    3721   fi
    3722 fi
    3723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
    3724 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
    3725 if ${ac_cv_prog_cc_c89+:} false; then :
    3726   $as_echo_n "(cached) " >&6
    3727 else
    3728   ac_cv_prog_cc_c89=no
    3729 ac_save_CC=$CC
    3730 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3731 /* end confdefs.h.  */
    3732 #include <stdarg.h>
    3733 #include <stdio.h>
    3734 struct stat;
    3735 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
    3736 struct buf { int x; };
    3737 FILE * (*rcsopen) (struct buf *, struct stat *, int);
    3738 static char *e (p, i)
    3739      char **p;
    3740      int i;
    3741 {
    3742   return p[i];
    3743 }
    3744 static char *f (char * (*g) (char **, int), char **p, ...)
    3745 {
    3746   char *s;
    3747   va_list v;
    3748   va_start (v,p);
    3749   s = g (p, va_arg (v,int));
    3750   va_end (v);
    3751   return s;
    3752 }
    3753 
    3754 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
    3755    function prototypes and stuff, but not '\xHH' hex character constants.
    3756    These don't provoke an error unfortunately, instead are silently treated
    3757    as 'x'.  The following induces an error, until -std is added to get
    3758    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
    3759    array size at least.  It's necessary to write '\x00'==0 to get something
    3760    that's true only with -std.  */
    3761 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
    3762 
    3763 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
    3764    inside strings and character constants.  */
    3765 #define FOO(x) 'x'
    3766 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
    3767 
    3768 int test (int i, double x);
    3769 struct s1 {int (*f) (int a);};
    3770 struct s2 {int (*f) (double a);};
    3771 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
    3772 int argc;
    3773 char **argv;
    3774 int
    3775 main ()
    3776 {
    3777 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
    3778   ;
    3779   return 0;
    3780 }
    3781 _ACEOF
    3782 for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
    3783         -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
    3784 do
    3785   CC="$ac_save_CC $ac_arg"
    3786   if ac_fn_c_try_compile "$LINENO"; then :
    3787   ac_cv_prog_cc_c89=$ac_arg
    3788 fi
    3789 rm -f core conftest.err conftest.$ac_objext
    3790   test "x$ac_cv_prog_cc_c89" != "xno" && break
    3791 done
    3792 rm -f conftest.$ac_ext
    3793 CC=$ac_save_CC
    3794 
    3795 fi
    3796 # AC_CACHE_VAL
    3797 case "x$ac_cv_prog_cc_c89" in
    3798   x)
    3799     { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
    3800 $as_echo "none needed" >&6; } ;;
    3801   xno)
    3802     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
    3803 $as_echo "unsupported" >&6; } ;;
    3804   *)
    3805     CC="$CC $ac_cv_prog_cc_c89"
    3806     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
    3807 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
    3808 esac
    3809 if test "x$ac_cv_prog_cc_c89" != xno; then :
    3810 
    3811 fi
    3812 
    3813 ac_ext=c
    3814 ac_cpp='$CPP $CPPFLAGS'
    3815 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    3816 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    3817 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    3818 
    3819 ac_ext=c
    3820 ac_cpp='$CPP $CPPFLAGS'
    3821 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    3822 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    3823 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    3824 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
    3825 $as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
    3826 if ${am_cv_prog_cc_c_o+:} false; then :
    3827   $as_echo_n "(cached) " >&6
    3828 else
    3829   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    3830 /* end confdefs.h.  */
    3831 
    3832 int
    3833 main ()
    3834 {
    3835 
    3836   ;
    3837   return 0;
    3838 }
    3839 _ACEOF
    3840   # Make sure it works both with $CC and with simple cc.
    3841   # Following AC_PROG_CC_C_O, we do the test twice because some
    3842   # compilers refuse to overwrite an existing .o file with -o,
    3843   # though they will create one.
    3844   am_cv_prog_cc_c_o=yes
    3845   for am_i in 1 2; do
    3846     if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
    3847    ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
    3848    ac_status=$?
    3849    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    3850    (exit $ac_status); } \
    3851          && test -f conftest2.$ac_objext; then
    3852       : OK
    3853     else
    3854       am_cv_prog_cc_c_o=no
    3855       break
    3856     fi
    3857   done
    3858   rm -f core conftest*
    3859   unset am_i
    3860 fi
    3861 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
    3862 $as_echo "$am_cv_prog_cc_c_o" >&6; }
    3863 if test "$am_cv_prog_cc_c_o" != yes; then
    3864    # Losing compiler, so override with the script.
    3865    # FIXME: It is wrong to rewrite CC.
    3866    # But if we don't then we get into trouble of one sort or another.
    3867    # A longer-term fix would be to have automake use am__CC in this case,
    3868    # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
    3869    CC="$am_aux_dir/compile $CC"
    3870 fi
    3871 ac_ext=c
    3872 ac_cpp='$CPP $CPPFLAGS'
    3873 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    3874 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    3875 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    3876 
    3877 
    3878 depcc="$CC"   am_compiler_list=
    3879 
    3880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
    3881 $as_echo_n "checking dependency style of $depcc... " >&6; }
    3882 if ${am_cv_CC_dependencies_compiler_type+:} false; then :
    3883   $as_echo_n "(cached) " >&6
    3884 else
    3885   if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
    3886   # We make a subdir and do the tests there.  Otherwise we can end up
    3887   # making bogus files that we don't know about and never remove.  For
    3888   # instance it was reported that on HP-UX the gcc test will end up
    3889   # making a dummy file named 'D' -- because '-MD' means "put the output
    3890   # in D".
    3891   rm -rf conftest.dir
    3892   mkdir conftest.dir
    3893   # Copy depcomp to subdir because otherwise we won't find it if we're
    3894   # using a relative directory.
    3895   cp "$am_depcomp" conftest.dir
    3896   cd conftest.dir
    3897   # We will build objects and dependencies in a subdirectory because
    3898   # it helps to detect inapplicable dependency modes.  For instance
    3899   # both Tru64's cc and ICC support -MD to output dependencies as a
    3900   # side effect of compilation, but ICC will put the dependencies in
    3901   # the current directory while Tru64 will put them in the object
    3902   # directory.
    3903   mkdir sub
    3904 
    3905   am_cv_CC_dependencies_compiler_type=none
    3906   if test "$am_compiler_list" = ""; then
    3907      am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
    3908   fi
    3909   am__universal=false
    3910   case " $depcc " in #(
    3911      *\ -arch\ *\ -arch\ *) am__universal=true ;;
    3912      esac
    3913 
    3914   for depmode in $am_compiler_list; do
    3915     # Setup a source with many dependencies, because some compilers
    3916     # like to wrap large dependency lists on column 80 (with \), and
    3917     # we should not choose a depcomp mode which is confused by this.
    3918     #
    3919     # We need to recreate these files for each test, as the compiler may
    3920     # overwrite some of them when testing with obscure command lines.
    3921     # This happens at least with the AIX C compiler.
    3922     : > sub/conftest.c
    3923     for i in 1 2 3 4 5 6; do
    3924       echo '#include "conftst'$i'.h"' >> sub/conftest.c
    3925       # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
    3926       # Solaris 10 /bin/sh.
    3927       echo '/* dummy */' > sub/conftst$i.h
    3928     done
    3929     echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    3930 
    3931     # We check with '-c' and '-o' for the sake of the "dashmstdout"
    3932     # mode.  It turns out that the SunPro C++ compiler does not properly
    3933     # handle '-M -o', and we need to detect this.  Also, some Intel
    3934     # versions had trouble with output in subdirs.
    3935     am__obj=sub/conftest.${OBJEXT-o}
    3936     am__minus_obj="-o $am__obj"
    3937     case $depmode in
    3938     gcc)
    3939       # This depmode causes a compiler race in universal mode.
    3940       test "$am__universal" = false || continue
    3941       ;;
    3942     nosideeffect)
    3943       # After this tag, mechanisms are not by side-effect, so they'll
    3944       # only be used when explicitly requested.
    3945       if test "x$enable_dependency_tracking" = xyes; then
    3946         continue
    3947       else
    3948         break
    3949       fi
    3950       ;;
    3951     msvc7 | msvc7msys | msvisualcpp | msvcmsys)
    3952       # This compiler won't grok '-c -o', but also, the minuso test has
    3953       # not run yet.  These depmodes are late enough in the game, and
    3954       # so weak that their functioning should not be impacted.
    3955       am__obj=conftest.${OBJEXT-o}
    3956       am__minus_obj=
    3957       ;;
    3958     none) break ;;
    3959     esac
    3960     if depmode=$depmode \
    3961        source=sub/conftest.c object=$am__obj \
    3962        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
    3963        $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
    3964          >/dev/null 2>conftest.err &&
    3965        grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
    3966        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
    3967        grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
    3968        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
    3969       # icc doesn't choke on unknown options, it will just issue warnings
    3970       # or remarks (even with -Werror).  So we grep stderr for any message
    3971       # that says an option was ignored or not supported.
    3972       # When given -MP, icc 7.0 and 7.1 complain thusly:
    3973       #   icc: Command line warning: ignoring option '-M'; no argument required
    3974       # The diagnosis changed in icc 8.0:
    3975       #   icc: Command line remark: option '-MP' not supported
    3976       if (grep 'ignoring option' conftest.err ||
    3977           grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
    3978         am_cv_CC_dependencies_compiler_type=$depmode
    3979         break
    3980       fi
    3981     fi
    3982   done
    3983 
    3984   cd ..
    3985   rm -rf conftest.dir
    3986 else
    3987   am_cv_CC_dependencies_compiler_type=none
    3988 fi
    3989 
    3990 fi
    3991 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
    3992 $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
    3993 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
    3994 
    3995  if
    3996   test "x$enable_dependency_tracking" != xno \
    3997   && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
    3998   am__fastdepCC_TRUE=
    3999   am__fastdepCC_FALSE='#'
    4000 else
    4001   am__fastdepCC_TRUE='#'
    4002   am__fastdepCC_FALSE=
    4003 fi
    4004 
    4005 
    4006 
    4007 
    4008 # Set up libtool.
    4009 
    4010 case `pwd` in
    4011   *\ * | *\     *)
    4012     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
    4013 $as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
    4014 esac
    4015 
    4016 
    4017 
    4018 macro_version='2.4.6'
    4019 macro_revision='2.4.6'
    4020 
    4021 
    4022 
    4023 
    4024 
    4025 
    4026 
    4027 
    4028 
    4029 
    4030 
    4031 
    4032 
    4033 ltmain=$ac_aux_dir/ltmain.sh
    4034 
    4035 # Backslashify metacharacters that are still active within
    4036 # double-quoted strings.
    4037 sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
    4038 
    4039 # Same as above, but do not quote variable references.
    4040 double_quote_subst='s/\(["`\\]\)/\\\1/g'
    4041 
    4042 # Sed substitution to delay expansion of an escaped shell variable in a
    4043 # double_quote_subst'ed string.
    4044 delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
    4045 
    4046 # Sed substitution to delay expansion of an escaped single quote.
    4047 delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
    4048 
    4049 # Sed substitution to avoid accidental globbing in evaled expressions
    4050 no_glob_subst='s/\*/\\\*/g'
    4051 
    4052 ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    4053 ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
    4054 ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
    4055 
    4056 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
    4057 $as_echo_n "checking how to print strings... " >&6; }
    4058 # Test print first, because it will be a builtin if present.
    4059 if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
    4060    test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
    4061   ECHO='print -r --'
    4062 elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
    4063   ECHO='printf %s\n'
    4064 else
    4065   # Use this function as a fallback that always works.
    4066   func_fallback_echo ()
    4067   {
    4068     eval 'cat <<_LTECHO_EOF
    4069 $1
    4070 _LTECHO_EOF'
    4071   }
    4072   ECHO='func_fallback_echo'
    4073 fi
    4074 
    4075 # func_echo_all arg...
    4076 # Invoke $ECHO with all args, space-separated.
    4077 func_echo_all ()
    4078 {
    4079     $ECHO ""
    4080 }
    4081 
    4082 case $ECHO in
    4083   printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
    4084 $as_echo "printf" >&6; } ;;
    4085   print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
    4086 $as_echo "print -r" >&6; } ;;
    4087   *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
    4088 $as_echo "cat" >&6; } ;;
    4089 esac
    4090 
    4091 
    4092 
    4093 
    4094 
    4095 
    4096 
    4097 
    4098 
    4099 
    4100 
    4101 
    4102 
    4103 
    4104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
    4105 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
    4106 if ${ac_cv_path_SED+:} false; then :
    4107   $as_echo_n "(cached) " >&6
    4108 else
    4109             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
    4110      for ac_i in 1 2 3 4 5 6 7; do
    4111        ac_script="$ac_script$as_nl$ac_script"
    4112      done
    4113      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
    4114      { ac_script=; unset ac_script;}
    4115      if test -z "$SED"; then
    4116   ac_path_SED_found=false
    4117   # Loop through the user's path and test for each of PROGNAME-LIST
    4118   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    4119 for as_dir in $PATH
    4120 do
    4121   IFS=$as_save_IFS
    4122   test -z "$as_dir" && as_dir=.
    4123     for ac_prog in sed gsed; do
    4124     for ac_exec_ext in '' $ac_executable_extensions; do
    4125       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
    4126       as_fn_executable_p "$ac_path_SED" || continue
    4127 # Check for GNU ac_path_SED and select it if it is found.
    4128   # Check for GNU $ac_path_SED
    4129 case `"$ac_path_SED" --version 2>&1` in
    4130 *GNU*)
    4131   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
    4132 *)
    4133   ac_count=0
    4134   $as_echo_n 0123456789 >"conftest.in"
    4135   while :
    4136   do
    4137     cat "conftest.in" "conftest.in" >"conftest.tmp"
    4138     mv "conftest.tmp" "conftest.in"
    4139     cp "conftest.in" "conftest.nl"
    4140     $as_echo '' >> "conftest.nl"
    4141     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
    4142     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    4143     as_fn_arith $ac_count + 1 && ac_count=$as_val
    4144     if test $ac_count -gt ${ac_path_SED_max-0}; then
    4145       # Best one so far, save it but keep looking for a better one
    4146       ac_cv_path_SED="$ac_path_SED"
    4147       ac_path_SED_max=$ac_count
    4148     fi
    4149     # 10*(2^10) chars as input seems more than enough
    4150     test $ac_count -gt 10 && break
    4151   done
    4152   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
    4153 esac
    4154 
    4155       $ac_path_SED_found && break 3
    4156     done
    4157   done
    4158   done
    4159 IFS=$as_save_IFS
    4160   if test -z "$ac_cv_path_SED"; then
    4161     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
    4162   fi
    4163 else
    4164   ac_cv_path_SED=$SED
    4165 fi
    4166 
    4167 fi
    4168 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
    4169 $as_echo "$ac_cv_path_SED" >&6; }
    4170  SED="$ac_cv_path_SED"
    4171   rm -f conftest.sed
    4172 
    4173 test -z "$SED" && SED=sed
    4174 Xsed="$SED -e 1s/^X//"
    4175 
    4176 
    4177 
    4178 
    4179 
    4180 
    4181 
    4182 
    4183 
    4184 
    4185 
    4186 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
    4187 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
    4188 if ${ac_cv_path_GREP+:} false; then :
    4189   $as_echo_n "(cached) " >&6
    4190 else
    4191   if test -z "$GREP"; then
    4192   ac_path_GREP_found=false
    4193   # Loop through the user's path and test for each of PROGNAME-LIST
    4194   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    4195 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
    4196 do
    4197   IFS=$as_save_IFS
    4198   test -z "$as_dir" && as_dir=.
    4199     for ac_prog in grep ggrep; do
    4200     for ac_exec_ext in '' $ac_executable_extensions; do
    4201       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
    4202       as_fn_executable_p "$ac_path_GREP" || continue
    4203 # Check for GNU ac_path_GREP and select it if it is found.
    4204   # Check for GNU $ac_path_GREP
    4205 case `"$ac_path_GREP" --version 2>&1` in
    4206 *GNU*)
    4207   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
    4208 *)
    4209   ac_count=0
    4210   $as_echo_n 0123456789 >"conftest.in"
    4211   while :
    4212   do
    4213     cat "conftest.in" "conftest.in" >"conftest.tmp"
    4214     mv "conftest.tmp" "conftest.in"
    4215     cp "conftest.in" "conftest.nl"
    4216     $as_echo 'GREP' >> "conftest.nl"
    4217     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    4218     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    4219     as_fn_arith $ac_count + 1 && ac_count=$as_val
    4220     if test $ac_count -gt ${ac_path_GREP_max-0}; then
    4221       # Best one so far, save it but keep looking for a better one
    4222       ac_cv_path_GREP="$ac_path_GREP"
    4223       ac_path_GREP_max=$ac_count
    4224     fi
    4225     # 10*(2^10) chars as input seems more than enough
    4226     test $ac_count -gt 10 && break
    4227   done
    4228   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
    4229 esac
    4230 
    4231       $ac_path_GREP_found && break 3
    4232     done
    4233   done
    4234   done
    4235 IFS=$as_save_IFS
    4236   if test -z "$ac_cv_path_GREP"; then
    4237     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
    4238   fi
    4239 else
    4240   ac_cv_path_GREP=$GREP
    4241 fi
    4242 
    4243 fi
    4244 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
    4245 $as_echo "$ac_cv_path_GREP" >&6; }
    4246  GREP="$ac_cv_path_GREP"
    4247 
    4248 
    4249 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
    4250 $as_echo_n "checking for egrep... " >&6; }
    4251 if ${ac_cv_path_EGREP+:} false; then :
    4252   $as_echo_n "(cached) " >&6
    4253 else
    4254   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
    4255    then ac_cv_path_EGREP="$GREP -E"
    4256    else
    4257      if test -z "$EGREP"; then
    4258   ac_path_EGREP_found=false
    4259   # Loop through the user's path and test for each of PROGNAME-LIST
    4260   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    4261 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
    4262 do
    4263   IFS=$as_save_IFS
    4264   test -z "$as_dir" && as_dir=.
    4265     for ac_prog in egrep; do
    4266     for ac_exec_ext in '' $ac_executable_extensions; do
    4267       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
    4268       as_fn_executable_p "$ac_path_EGREP" || continue
    4269 # Check for GNU ac_path_EGREP and select it if it is found.
    4270   # Check for GNU $ac_path_EGREP
    4271 case `"$ac_path_EGREP" --version 2>&1` in
    4272 *GNU*)
    4273   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
    4274 *)
    4275   ac_count=0
    4276   $as_echo_n 0123456789 >"conftest.in"
    4277   while :
    4278   do
    4279     cat "conftest.in" "conftest.in" >"conftest.tmp"
    4280     mv "conftest.tmp" "conftest.in"
    4281     cp "conftest.in" "conftest.nl"
    4282     $as_echo 'EGREP' >> "conftest.nl"
    4283     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    4284     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    4285     as_fn_arith $ac_count + 1 && ac_count=$as_val
    4286     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
    4287       # Best one so far, save it but keep looking for a better one
    4288       ac_cv_path_EGREP="$ac_path_EGREP"
    4289       ac_path_EGREP_max=$ac_count
    4290     fi
    4291     # 10*(2^10) chars as input seems more than enough
    4292     test $ac_count -gt 10 && break
    4293   done
    4294   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
    4295 esac
    4296 
    4297       $ac_path_EGREP_found && break 3
    4298     done
    4299   done
    4300   done
    4301 IFS=$as_save_IFS
    4302   if test -z "$ac_cv_path_EGREP"; then
    4303     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
    4304   fi
    4305 else
    4306   ac_cv_path_EGREP=$EGREP
    4307 fi
    4308 
    4309    fi
    4310 fi
    4311 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
    4312 $as_echo "$ac_cv_path_EGREP" >&6; }
    4313  EGREP="$ac_cv_path_EGREP"
    4314 
    4315 
    4316 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
    4317 $as_echo_n "checking for fgrep... " >&6; }
    4318 if ${ac_cv_path_FGREP+:} false; then :
    4319   $as_echo_n "(cached) " >&6
    4320 else
    4321   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
    4322    then ac_cv_path_FGREP="$GREP -F"
    4323    else
    4324      if test -z "$FGREP"; then
    4325   ac_path_FGREP_found=false
    4326   # Loop through the user's path and test for each of PROGNAME-LIST
    4327   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    4328 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
    4329 do
    4330   IFS=$as_save_IFS
    4331   test -z "$as_dir" && as_dir=.
    4332     for ac_prog in fgrep; do
    4333     for ac_exec_ext in '' $ac_executable_extensions; do
    4334       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
    4335       as_fn_executable_p "$ac_path_FGREP" || continue
    4336 # Check for GNU ac_path_FGREP and select it if it is found.
    4337   # Check for GNU $ac_path_FGREP
    4338 case `"$ac_path_FGREP" --version 2>&1` in
    4339 *GNU*)
    4340   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
    4341 *)
    4342   ac_count=0
    4343   $as_echo_n 0123456789 >"conftest.in"
    4344   while :
    4345   do
    4346     cat "conftest.in" "conftest.in" >"conftest.tmp"
    4347     mv "conftest.tmp" "conftest.in"
    4348     cp "conftest.in" "conftest.nl"
    4349     $as_echo 'FGREP' >> "conftest.nl"
    4350     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
    4351     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    4352     as_fn_arith $ac_count + 1 && ac_count=$as_val
    4353     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
    4354       # Best one so far, save it but keep looking for a better one
    4355       ac_cv_path_FGREP="$ac_path_FGREP"
    4356       ac_path_FGREP_max=$ac_count
    4357     fi
    4358     # 10*(2^10) chars as input seems more than enough
    4359     test $ac_count -gt 10 && break
    4360   done
    4361   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
    4362 esac
    4363 
    4364       $ac_path_FGREP_found && break 3
    4365     done
    4366   done
    4367   done
    4368 IFS=$as_save_IFS
    4369   if test -z "$ac_cv_path_FGREP"; then
    4370     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
    4371   fi
    4372 else
    4373   ac_cv_path_FGREP=$FGREP
    4374 fi
    4375 
    4376    fi
    4377 fi
    4378 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
    4379 $as_echo "$ac_cv_path_FGREP" >&6; }
    4380  FGREP="$ac_cv_path_FGREP"
    4381 
    4382 
    4383 test -z "$GREP" && GREP=grep
    4384 
    4385 
    4386 
    4387 
    4388 
    4389 
    4390 
    4391 
    4392 
    4393 
    4394 
    4395 
    4396 
    4397 
    4398 
    4399 
    4400 
    4401 
    4402 
    4403 # Check whether --with-gnu-ld was given.
    4404 if test "${with_gnu_ld+set}" = set; then :
    4405   withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
    4406 else
    4407   with_gnu_ld=no
    4408 fi
    4409 
    4410 ac_prog=ld
    4411 if test yes = "$GCC"; then
    4412   # Check if gcc -print-prog-name=ld gives a path.
    4413   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
    4414 $as_echo_n "checking for ld used by $CC... " >&6; }
    4415   case $host in
    4416   *-*-mingw*)
    4417     # gcc leaves a trailing carriage return, which upsets mingw
    4418     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
    4419   *)
    4420     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
    4421   esac
    4422   case $ac_prog in
    4423     # Accept absolute paths.
    4424     [\\/]* | ?:[\\/]*)
    4425       re_direlt='/[^/][^/]*/\.\./'
    4426       # Canonicalize the pathname of ld
    4427       ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
    4428       while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
    4429         ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
    4430       done
    4431       test -z "$LD" && LD=$ac_prog
    4432       ;;
    4433   "")
    4434     # If it fails, then pretend we aren't using GCC.
    4435     ac_prog=ld
    4436     ;;
    4437   *)
    4438     # If it is relative, then search for the first ld in PATH.
    4439     with_gnu_ld=unknown
    4440     ;;
    4441   esac
    4442 elif test yes = "$with_gnu_ld"; then
    4443   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
    4444 $as_echo_n "checking for GNU ld... " >&6; }
    4445 else
    4446   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
    4447 $as_echo_n "checking for non-GNU ld... " >&6; }
    4448 fi
    4449 if ${lt_cv_path_LD+:} false; then :
    4450   $as_echo_n "(cached) " >&6
    4451 else
    4452   if test -z "$LD"; then
    4453   lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
    4454   for ac_dir in $PATH; do
    4455     IFS=$lt_save_ifs
    4456     test -z "$ac_dir" && ac_dir=.
    4457     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
    4458       lt_cv_path_LD=$ac_dir/$ac_prog
    4459       # Check to see if the program is GNU ld.  I'd rather use --version,
    4460       # but apparently some variants of GNU ld only accept -v.
    4461       # Break only if it was the GNU/non-GNU ld that we prefer.
    4462       case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
    4463       *GNU* | *'with BFD'*)
    4464         test no != "$with_gnu_ld" && break
    4465         ;;
    4466       *)
    4467         test yes != "$with_gnu_ld" && break
    4468         ;;
    4469       esac
    4470     fi
    4471   done
    4472   IFS=$lt_save_ifs
    4473 else
    4474   lt_cv_path_LD=$LD # Let the user override the test with a path.
    4475 fi
    4476 fi
    4477 
    4478 LD=$lt_cv_path_LD
    4479 if test -n "$LD"; then
    4480   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
    4481 $as_echo "$LD" >&6; }
    4482 else
    4483   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    4484 $as_echo "no" >&6; }
    4485 fi
    4486 test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
    4487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
    4488 $as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
    4489 if ${lt_cv_prog_gnu_ld+:} false; then :
    4490   $as_echo_n "(cached) " >&6
    4491 else
    4492   # I'd rather use --version here, but apparently some GNU lds only accept -v.
    4493 case `$LD -v 2>&1 </dev/null` in
    4494 *GNU* | *'with BFD'*)
    4495   lt_cv_prog_gnu_ld=yes
    4496   ;;
    4497 *)
    4498   lt_cv_prog_gnu_ld=no
    4499   ;;
    4500 esac
    4501 fi
    4502 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
    4503 $as_echo "$lt_cv_prog_gnu_ld" >&6; }
    4504 with_gnu_ld=$lt_cv_prog_gnu_ld
    4505 
    4506 
    4507 
    4508 
    4509 
    4510 
    4511 
    4512 
    4513 
    4514 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
    4515 $as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
    4516 if ${lt_cv_path_NM+:} false; then :
    4517   $as_echo_n "(cached) " >&6
    4518 else
    4519   if test -n "$NM"; then
    4520   # Let the user override the test.
    4521   lt_cv_path_NM=$NM
    4522 else
    4523   lt_nm_to_check=${ac_tool_prefix}nm
    4524   if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
    4525     lt_nm_to_check="$lt_nm_to_check nm"
    4526   fi
    4527   for lt_tmp_nm in $lt_nm_to_check; do
    4528     lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
    4529     for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
    4530       IFS=$lt_save_ifs
    4531       test -z "$ac_dir" && ac_dir=.
    4532       tmp_nm=$ac_dir/$lt_tmp_nm
    4533       if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
    4534         # Check to see if the nm accepts a BSD-compat flag.
    4535         # Adding the 'sed 1q' prevents false positives on HP-UX, which says:
    4536         #   nm: unknown option "B" ignored
    4537         # Tru64's nm complains that /dev/null is an invalid object file
    4538         # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
    4539         case $build_os in
    4540         mingw*) lt_bad_file=conftest.nm/nofile ;;
    4541         *) lt_bad_file=/dev/null ;;
    4542         esac
    4543         case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
    4544         *$lt_bad_file* | *'Invalid file or object type'*)
    4545           lt_cv_path_NM="$tmp_nm -B"
    4546           break 2
    4547           ;;
    4548         *)
    4549           case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
    4550           */dev/null*)
    4551             lt_cv_path_NM="$tmp_nm -p"
    4552             break 2
    4553             ;;
    4554           *)
    4555             lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
    4556             continue # so that we can try to find one that supports BSD flags
    4557             ;;
    4558           esac
    4559           ;;
    4560         esac
    4561       fi
    4562     done
    4563     IFS=$lt_save_ifs
    4564   done
    4565   : ${lt_cv_path_NM=no}
    4566 fi
    4567 fi
    4568 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
    4569 $as_echo "$lt_cv_path_NM" >&6; }
    4570 if test no != "$lt_cv_path_NM"; then
    4571   NM=$lt_cv_path_NM
    4572 else
    4573   # Didn't find any BSD compatible name lister, look for dumpbin.
    4574   if test -n "$DUMPBIN"; then :
    4575     # Let the user override the test.
    4576   else
    4577     if test -n "$ac_tool_prefix"; then
    4578   for ac_prog in dumpbin "link -dump"
    4579   do
    4580     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    4581 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    4582 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    4583 $as_echo_n "checking for $ac_word... " >&6; }
    4584 if ${ac_cv_prog_DUMPBIN+:} false; then :
    4585   $as_echo_n "(cached) " >&6
    4586 else
    4587   if test -n "$DUMPBIN"; then
    4588   ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
    4589 else
    4590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    4591 for as_dir in $PATH
    4592 do
    4593   IFS=$as_save_IFS
    4594   test -z "$as_dir" && as_dir=.
    4595     for ac_exec_ext in '' $ac_executable_extensions; do
    4596   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    4597     ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
    4598     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    4599     break 2
    4600   fi
    4601 done
    4602   done
    4603 IFS=$as_save_IFS
    4604 
    4605 fi
    4606 fi
    4607 DUMPBIN=$ac_cv_prog_DUMPBIN
    4608 if test -n "$DUMPBIN"; then
    4609   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
    4610 $as_echo "$DUMPBIN" >&6; }
    4611 else
    4612   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    4613 $as_echo "no" >&6; }
    4614 fi
    4615 
    4616 
    4617     test -n "$DUMPBIN" && break
    4618   done
    4619 fi
    4620 if test -z "$DUMPBIN"; then
    4621   ac_ct_DUMPBIN=$DUMPBIN
    4622   for ac_prog in dumpbin "link -dump"
    4623 do
    4624   # Extract the first word of "$ac_prog", so it can be a program name with args.
    4625 set dummy $ac_prog; ac_word=$2
    4626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    4627 $as_echo_n "checking for $ac_word... " >&6; }
    4628 if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then :
    4629   $as_echo_n "(cached) " >&6
    4630 else
    4631   if test -n "$ac_ct_DUMPBIN"; then
    4632   ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
    4633 else
    4634 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    4635 for as_dir in $PATH
    4636 do
    4637   IFS=$as_save_IFS
    4638   test -z "$as_dir" && as_dir=.
    4639     for ac_exec_ext in '' $ac_executable_extensions; do
    4640   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    4641     ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
    4642     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    4643     break 2
    4644   fi
    4645 done
    4646   done
    4647 IFS=$as_save_IFS
    4648 
    4649 fi
    4650 fi
    4651 ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
    4652 if test -n "$ac_ct_DUMPBIN"; then
    4653   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
    4654 $as_echo "$ac_ct_DUMPBIN" >&6; }
    4655 else
    4656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    4657 $as_echo "no" >&6; }
    4658 fi
    4659 
    4660 
    4661   test -n "$ac_ct_DUMPBIN" && break
    4662 done
    4663 
    4664   if test "x$ac_ct_DUMPBIN" = x; then
    4665     DUMPBIN=":"
    4666   else
    4667     case $cross_compiling:$ac_tool_warned in
    4668 yes:)
    4669 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    4670 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    4671 ac_tool_warned=yes ;;
    4672 esac
    4673     DUMPBIN=$ac_ct_DUMPBIN
    4674   fi
    4675 fi
    4676 
    4677     case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
    4678     *COFF*)
    4679       DUMPBIN="$DUMPBIN -symbols -headers"
    4680       ;;
    4681     *)
    4682       DUMPBIN=:
    4683       ;;
    4684     esac
    4685   fi
    4686 
    4687   if test : != "$DUMPBIN"; then
    4688     NM=$DUMPBIN
    4689   fi
    4690 fi
    4691 test -z "$NM" && NM=nm
    4692 
    4693 
    4694 
    4695 
    4696 
    4697 
    4698 { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
    4699 $as_echo_n "checking the name lister ($NM) interface... " >&6; }
    4700 if ${lt_cv_nm_interface+:} false; then :
    4701   $as_echo_n "(cached) " >&6
    4702 else
    4703   lt_cv_nm_interface="BSD nm"
    4704   echo "int some_variable = 0;" > conftest.$ac_ext
    4705   (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
    4706   (eval "$ac_compile" 2>conftest.err)
    4707   cat conftest.err >&5
    4708   (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
    4709   (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
    4710   cat conftest.err >&5
    4711   (eval echo "\"\$as_me:$LINENO: output\"" >&5)
    4712   cat conftest.out >&5
    4713   if $GREP 'External.*some_variable' conftest.out > /dev/null; then
    4714     lt_cv_nm_interface="MS dumpbin"
    4715   fi
    4716   rm -f conftest*
    4717 fi
    4718 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
    4719 $as_echo "$lt_cv_nm_interface" >&6; }
    4720 
    4721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
    4722 $as_echo_n "checking whether ln -s works... " >&6; }
    4723 LN_S=$as_ln_s
    4724 if test "$LN_S" = "ln -s"; then
    4725   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
    4726 $as_echo "yes" >&6; }
    4727 else
    4728   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
    4729 $as_echo "no, using $LN_S" >&6; }
    4730 fi
    4731 
    4732 # find the maximum length of command line arguments
    4733 { $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
    4734 $as_echo_n "checking the maximum length of command line arguments... " >&6; }
    4735 if ${lt_cv_sys_max_cmd_len+:} false; then :
    4736   $as_echo_n "(cached) " >&6
    4737 else
    4738     i=0
    4739   teststring=ABCD
    4740 
    4741   case $build_os in
    4742   msdosdjgpp*)
    4743     # On DJGPP, this test can blow up pretty badly due to problems in libc
    4744     # (any single argument exceeding 2000 bytes causes a buffer overrun
    4745     # during glob expansion).  Even if it were fixed, the result of this
    4746     # check would be larger than it should be.
    4747     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
    4748     ;;
    4749 
    4750   gnu*)
    4751     # Under GNU Hurd, this test is not required because there is
    4752     # no limit to the length of command line arguments.
    4753     # Libtool will interpret -1 as no limit whatsoever
    4754     lt_cv_sys_max_cmd_len=-1;
    4755     ;;
    4756 
    4757   cygwin* | mingw* | cegcc*)
    4758     # On Win9x/ME, this test blows up -- it succeeds, but takes
    4759     # about 5 minutes as the teststring grows exponentially.
    4760     # Worse, since 9x/ME are not pre-emptively multitasking,
    4761     # you end up with a "frozen" computer, even though with patience
    4762     # the test eventually succeeds (with a max line length of 256k).
    4763     # Instead, let's just punt: use the minimum linelength reported by
    4764     # all of the supported platforms: 8192 (on NT/2K/XP).
    4765     lt_cv_sys_max_cmd_len=8192;
    4766     ;;
    4767 
    4768   mint*)
    4769     # On MiNT this can take a long time and run out of memory.
    4770     lt_cv_sys_max_cmd_len=8192;
    4771     ;;
    4772 
    4773   amigaos*)
    4774     # On AmigaOS with pdksh, this test takes hours, literally.
    4775     # So we just punt and use a minimum line length of 8192.
    4776     lt_cv_sys_max_cmd_len=8192;
    4777     ;;
    4778 
    4779   bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
    4780     # This has been around since 386BSD, at least.  Likely further.
    4781     if test -x /sbin/sysctl; then
    4782       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
    4783     elif test -x /usr/sbin/sysctl; then
    4784       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
    4785     else
    4786       lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
    4787     fi
    4788     # And add a safety zone
    4789     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
    4790     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    4791     ;;
    4792 
    4793   interix*)
    4794     # We know the value 262144 and hardcode it with a safety zone (like BSD)
    4795     lt_cv_sys_max_cmd_len=196608
    4796     ;;
    4797 
    4798   os2*)
    4799     # The test takes a long time on OS/2.
    4800     lt_cv_sys_max_cmd_len=8192
    4801     ;;
    4802 
    4803   osf*)
    4804     # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
    4805     # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
    4806     # nice to cause kernel panics so lets avoid the loop below.
    4807     # First set a reasonable default.
    4808     lt_cv_sys_max_cmd_len=16384
    4809     #
    4810     if test -x /sbin/sysconfig; then
    4811       case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
    4812         *1*) lt_cv_sys_max_cmd_len=-1 ;;
    4813       esac
    4814     fi
    4815     ;;
    4816   sco3.2v5*)
    4817     lt_cv_sys_max_cmd_len=102400
    4818     ;;
    4819   sysv5* | sco5v6* | sysv4.2uw2*)
    4820     kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
    4821     if test -n "$kargmax"; then
    4822       lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[  ]//'`
    4823     else
    4824       lt_cv_sys_max_cmd_len=32768
    4825     fi
    4826     ;;
    4827   *)
    4828     lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
    4829     if test -n "$lt_cv_sys_max_cmd_len" && \
    4830        test undefined != "$lt_cv_sys_max_cmd_len"; then
    4831       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
    4832       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    4833     else
    4834       # Make teststring a little bigger before we do anything with it.
    4835       # a 1K string should be a reasonable start.
    4836       for i in 1 2 3 4 5 6 7 8; do
    4837         teststring=$teststring$teststring
    4838       done
    4839       SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
    4840       # If test is not a shell built-in, we'll probably end up computing a
    4841       # maximum length that is only half of the actual maximum length, but
    4842       # we can't tell.
    4843       while { test X`env echo "$teststring$teststring" 2>/dev/null` \
    4844                  = "X$teststring$teststring"; } >/dev/null 2>&1 &&
    4845               test 17 != "$i" # 1/2 MB should be enough
    4846       do
    4847         i=`expr $i + 1`
    4848         teststring=$teststring$teststring
    4849       done
    4850       # Only check the string length outside the loop.
    4851       lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
    4852       teststring=
    4853       # Add a significant safety factor because C++ compilers can tack on
    4854       # massive amounts of additional arguments before passing them to the
    4855       # linker.  It appears as though 1/2 is a usable value.
    4856       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
    4857     fi
    4858     ;;
    4859   esac
    4860 
    4861 fi
    4862 
    4863 if test -n "$lt_cv_sys_max_cmd_len"; then
    4864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
    4865 $as_echo "$lt_cv_sys_max_cmd_len" >&6; }
    4866 else
    4867   { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
    4868 $as_echo "none" >&6; }
    4869 fi
    4870 max_cmd_len=$lt_cv_sys_max_cmd_len
    4871 
    4872 
    4873 
    4874 
    4875 
    4876 
    4877 : ${CP="cp -f"}
    4878 : ${MV="mv -f"}
    4879 : ${RM="rm -f"}
    4880 
    4881 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
    4882   lt_unset=unset
    4883 else
    4884   lt_unset=false
    4885 fi
    4886 
    4887 
    4888 
    4889 
    4890 
    4891 # test EBCDIC or ASCII
    4892 case `echo X|tr X '\101'` in
    4893  A) # ASCII based system
    4894     # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
    4895   lt_SP2NL='tr \040 \012'
    4896   lt_NL2SP='tr \015\012 \040\040'
    4897   ;;
    4898  *) # EBCDIC based system
    4899   lt_SP2NL='tr \100 \n'
    4900   lt_NL2SP='tr \r\n \100\100'
    4901   ;;
    4902 esac
    4903 
    4904 
    4905 
    4906 
    4907 
    4908 
    4909 
    4910 
    4911 
    4912 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
    4913 $as_echo_n "checking how to convert $build file names to $host format... " >&6; }
    4914 if ${lt_cv_to_host_file_cmd+:} false; then :
    4915   $as_echo_n "(cached) " >&6
    4916 else
    4917   case $host in
    4918   *-*-mingw* )
    4919     case $build in
    4920       *-*-mingw* ) # actually msys
    4921         lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
    4922         ;;
    4923       *-*-cygwin* )
    4924         lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
    4925         ;;
    4926       * ) # otherwise, assume *nix
    4927         lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
    4928         ;;
    4929     esac
    4930     ;;
    4931   *-*-cygwin* )
    4932     case $build in
    4933       *-*-mingw* ) # actually msys
    4934         lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
    4935         ;;
    4936       *-*-cygwin* )
    4937         lt_cv_to_host_file_cmd=func_convert_file_noop
    4938         ;;
    4939       * ) # otherwise, assume *nix
    4940         lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
    4941         ;;
    4942     esac
    4943     ;;
    4944   * ) # unhandled hosts (and "normal" native builds)
    4945     lt_cv_to_host_file_cmd=func_convert_file_noop
    4946     ;;
    4947 esac
    4948 
    4949 fi
    4950 
    4951 to_host_file_cmd=$lt_cv_to_host_file_cmd
    4952 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
    4953 $as_echo "$lt_cv_to_host_file_cmd" >&6; }
    4954 
    4955 
    4956 
    4957 
    4958 
    4959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
    4960 $as_echo_n "checking how to convert $build file names to toolchain format... " >&6; }
    4961 if ${lt_cv_to_tool_file_cmd+:} false; then :
    4962   $as_echo_n "(cached) " >&6
    4963 else
    4964   #assume ordinary cross tools, or native build.
    4965 lt_cv_to_tool_file_cmd=func_convert_file_noop
    4966 case $host in
    4967   *-*-mingw* )
    4968     case $build in
    4969       *-*-mingw* ) # actually msys
    4970         lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
    4971         ;;
    4972     esac
    4973     ;;
    4974 esac
    4975 
    4976 fi
    4977 
    4978 to_tool_file_cmd=$lt_cv_to_tool_file_cmd
    4979 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
    4980 $as_echo "$lt_cv_to_tool_file_cmd" >&6; }
    4981 
    4982 
    4983 
    4984 
    4985 
    4986 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
    4987 $as_echo_n "checking for $LD option to reload object files... " >&6; }
    4988 if ${lt_cv_ld_reload_flag+:} false; then :
    4989   $as_echo_n "(cached) " >&6
    4990 else
    4991   lt_cv_ld_reload_flag='-r'
    4992 fi
    4993 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
    4994 $as_echo "$lt_cv_ld_reload_flag" >&6; }
    4995 reload_flag=$lt_cv_ld_reload_flag
    4996 case $reload_flag in
    4997 "" | " "*) ;;
    4998 *) reload_flag=" $reload_flag" ;;
    4999 esac
    5000 reload_cmds='$LD$reload_flag -o $output$reload_objs'
    5001 case $host_os in
    5002   cygwin* | mingw* | pw32* | cegcc*)
    5003     if test yes != "$GCC"; then
    5004       reload_cmds=false
    5005     fi
    5006     ;;
    5007   darwin*)
    5008     if test yes = "$GCC"; then
    5009       reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
    5010     else
    5011       reload_cmds='$LD$reload_flag -o $output$reload_objs'
    5012     fi
    5013     ;;
    5014 esac
    5015 
    5016 
    5017 
    5018 
    5019 
    5020 
    5021 
    5022 
    5023 
    5024 if test -n "$ac_tool_prefix"; then
    5025   # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
    5026 set dummy ${ac_tool_prefix}objdump; ac_word=$2
    5027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5028 $as_echo_n "checking for $ac_word... " >&6; }
    5029 if ${ac_cv_prog_OBJDUMP+:} false; then :
    5030   $as_echo_n "(cached) " >&6
    5031 else
    5032   if test -n "$OBJDUMP"; then
    5033   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
    5034 else
    5035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5036 for as_dir in $PATH
    5037 do
    5038   IFS=$as_save_IFS
    5039   test -z "$as_dir" && as_dir=.
    5040     for ac_exec_ext in '' $ac_executable_extensions; do
    5041   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5042     ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
    5043     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5044     break 2
    5045   fi
    5046 done
    5047   done
    5048 IFS=$as_save_IFS
    5049 
    5050 fi
    5051 fi
    5052 OBJDUMP=$ac_cv_prog_OBJDUMP
    5053 if test -n "$OBJDUMP"; then
    5054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
    5055 $as_echo "$OBJDUMP" >&6; }
    5056 else
    5057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5058 $as_echo "no" >&6; }
    5059 fi
    5060 
    5061 
    5062 fi
    5063 if test -z "$ac_cv_prog_OBJDUMP"; then
    5064   ac_ct_OBJDUMP=$OBJDUMP
    5065   # Extract the first word of "objdump", so it can be a program name with args.
    5066 set dummy objdump; ac_word=$2
    5067 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5068 $as_echo_n "checking for $ac_word... " >&6; }
    5069 if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
    5070   $as_echo_n "(cached) " >&6
    5071 else
    5072   if test -n "$ac_ct_OBJDUMP"; then
    5073   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
    5074 else
    5075 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5076 for as_dir in $PATH
    5077 do
    5078   IFS=$as_save_IFS
    5079   test -z "$as_dir" && as_dir=.
    5080     for ac_exec_ext in '' $ac_executable_extensions; do
    5081   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5082     ac_cv_prog_ac_ct_OBJDUMP="objdump"
    5083     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5084     break 2
    5085   fi
    5086 done
    5087   done
    5088 IFS=$as_save_IFS
    5089 
    5090 fi
    5091 fi
    5092 ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
    5093 if test -n "$ac_ct_OBJDUMP"; then
    5094   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
    5095 $as_echo "$ac_ct_OBJDUMP" >&6; }
    5096 else
    5097   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5098 $as_echo "no" >&6; }
    5099 fi
    5100 
    5101   if test "x$ac_ct_OBJDUMP" = x; then
    5102     OBJDUMP="false"
    5103   else
    5104     case $cross_compiling:$ac_tool_warned in
    5105 yes:)
    5106 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    5107 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    5108 ac_tool_warned=yes ;;
    5109 esac
    5110     OBJDUMP=$ac_ct_OBJDUMP
    5111   fi
    5112 else
    5113   OBJDUMP="$ac_cv_prog_OBJDUMP"
    5114 fi
    5115 
    5116 test -z "$OBJDUMP" && OBJDUMP=objdump
    5117 
    5118 
    5119 
    5120 
    5121 
    5122 
    5123 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
    5124 $as_echo_n "checking how to recognize dependent libraries... " >&6; }
    5125 if ${lt_cv_deplibs_check_method+:} false; then :
    5126   $as_echo_n "(cached) " >&6
    5127 else
    5128   lt_cv_file_magic_cmd='$MAGIC_CMD'
    5129 lt_cv_file_magic_test_file=
    5130 lt_cv_deplibs_check_method='unknown'
    5131 # Need to set the preceding variable on all platforms that support
    5132 # interlibrary dependencies.
    5133 # 'none' -- dependencies not supported.
    5134 # 'unknown' -- same as none, but documents that we really don't know.
    5135 # 'pass_all' -- all dependencies passed with no checks.
    5136 # 'test_compile' -- check by making test program.
    5137 # 'file_magic [[regex]]' -- check by looking for files in library path
    5138 # that responds to the $file_magic_cmd with a given extended regex.
    5139 # If you have 'file' or equivalent on your system and you're not sure
    5140 # whether 'pass_all' will *always* work, you probably want this one.
    5141 
    5142 case $host_os in
    5143 aix[4-9]*)
    5144   lt_cv_deplibs_check_method=pass_all
    5145   ;;
    5146 
    5147 beos*)
    5148   lt_cv_deplibs_check_method=pass_all
    5149   ;;
    5150 
    5151 bsdi[45]*)
    5152   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
    5153   lt_cv_file_magic_cmd='/usr/bin/file -L'
    5154   lt_cv_file_magic_test_file=/shlib/libc.so
    5155   ;;
    5156 
    5157 cygwin*)
    5158   # func_win32_libid is a shell function defined in ltmain.sh
    5159   lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
    5160   lt_cv_file_magic_cmd='func_win32_libid'
    5161   ;;
    5162 
    5163 mingw* | pw32*)
    5164   # Base MSYS/MinGW do not provide the 'file' command needed by
    5165   # func_win32_libid shell function, so use a weaker test based on 'objdump',
    5166   # unless we find 'file', for example because we are cross-compiling.
    5167   if ( file / ) >/dev/null 2>&1; then
    5168     lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
    5169     lt_cv_file_magic_cmd='func_win32_libid'
    5170   else
    5171     # Keep this pattern in sync with the one in func_win32_libid.
    5172     lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
    5173     lt_cv_file_magic_cmd='$OBJDUMP -f'
    5174   fi
    5175   ;;
    5176 
    5177 cegcc*)
    5178   # use the weaker test based on 'objdump'. See mingw*.
    5179   lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
    5180   lt_cv_file_magic_cmd='$OBJDUMP -f'
    5181   ;;
    5182 
    5183 darwin* | rhapsody*)
    5184   lt_cv_deplibs_check_method=pass_all
    5185   ;;
    5186 
    5187 freebsd* | dragonfly*)
    5188   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    5189     case $host_cpu in
    5190     i*86 )
    5191       # Not sure whether the presence of OpenBSD here was a mistake.
    5192       # Let's accept both of them until this is cleared up.
    5193       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
    5194       lt_cv_file_magic_cmd=/usr/bin/file
    5195       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
    5196       ;;
    5197     esac
    5198   else
    5199     lt_cv_deplibs_check_method=pass_all
    5200   fi
    5201   ;;
    5202 
    5203 haiku*)
    5204   lt_cv_deplibs_check_method=pass_all
    5205   ;;
    5206 
    5207 hpux10.20* | hpux11*)
    5208   lt_cv_file_magic_cmd=/usr/bin/file
    5209   case $host_cpu in
    5210   ia64*)
    5211     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
    5212     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
    5213     ;;
    5214   hppa*64*)
    5215     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
    5216     lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
    5217     ;;
    5218   *)
    5219     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
    5220     lt_cv_file_magic_test_file=/usr/lib/libc.sl
    5221     ;;
    5222   esac
    5223   ;;
    5224 
    5225 interix[3-9]*)
    5226   # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
    5227   lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
    5228   ;;
    5229 
    5230 irix5* | irix6* | nonstopux*)
    5231   case $LD in
    5232   *-32|*"-32 ") libmagic=32-bit;;
    5233   *-n32|*"-n32 ") libmagic=N32;;
    5234   *-64|*"-64 ") libmagic=64-bit;;
    5235   *) libmagic=never-match;;
    5236   esac
    5237   lt_cv_deplibs_check_method=pass_all
    5238   ;;
    5239 
    5240 # This must be glibc/ELF.
    5241 linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
    5242   lt_cv_deplibs_check_method=pass_all
    5243   ;;
    5244 
    5245 netbsd*)
    5246   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    5247     lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
    5248   else
    5249     lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
    5250   fi
    5251   ;;
    5252 
    5253 newos6*)
    5254   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
    5255   lt_cv_file_magic_cmd=/usr/bin/file
    5256   lt_cv_file_magic_test_file=/usr/lib/libnls.so
    5257   ;;
    5258 
    5259 *nto* | *qnx*)
    5260   lt_cv_deplibs_check_method=pass_all
    5261   ;;
    5262 
    5263 openbsd* | bitrig*)
    5264   if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
    5265     lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
    5266   else
    5267     lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
    5268   fi
    5269   ;;
    5270 
    5271 osf3* | osf4* | osf5*)
    5272   lt_cv_deplibs_check_method=pass_all
    5273   ;;
    5274 
    5275 rdos*)
    5276   lt_cv_deplibs_check_method=pass_all
    5277   ;;
    5278 
    5279 solaris*)
    5280   lt_cv_deplibs_check_method=pass_all
    5281   ;;
    5282 
    5283 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
    5284   lt_cv_deplibs_check_method=pass_all
    5285   ;;
    5286 
    5287 sysv4 | sysv4.3*)
    5288   case $host_vendor in
    5289   motorola)
    5290     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]'
    5291     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
    5292     ;;
    5293   ncr)
    5294     lt_cv_deplibs_check_method=pass_all
    5295     ;;
    5296   sequent)
    5297     lt_cv_file_magic_cmd='/bin/file'
    5298     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
    5299     ;;
    5300   sni)
    5301     lt_cv_file_magic_cmd='/bin/file'
    5302     lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
    5303     lt_cv_file_magic_test_file=/lib/libc.so
    5304     ;;
    5305   siemens)
    5306     lt_cv_deplibs_check_method=pass_all
    5307     ;;
    5308   pc)
    5309     lt_cv_deplibs_check_method=pass_all
    5310     ;;
    5311   esac
    5312   ;;
    5313 
    5314 tpf*)
    5315   lt_cv_deplibs_check_method=pass_all
    5316   ;;
    5317 os2*)
    5318   lt_cv_deplibs_check_method=pass_all
    5319   ;;
    5320 esac
    5321 
    5322 fi
    5323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
    5324 $as_echo "$lt_cv_deplibs_check_method" >&6; }
    5325 
    5326 file_magic_glob=
    5327 want_nocaseglob=no
    5328 if test "$build" = "$host"; then
    5329   case $host_os in
    5330   mingw* | pw32*)
    5331     if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
    5332       want_nocaseglob=yes
    5333     else
    5334       file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"`
    5335     fi
    5336     ;;
    5337   esac
    5338 fi
    5339 
    5340 file_magic_cmd=$lt_cv_file_magic_cmd
    5341 deplibs_check_method=$lt_cv_deplibs_check_method
    5342 test -z "$deplibs_check_method" && deplibs_check_method=unknown
    5343 
    5344 
    5345 
    5346 
    5347 
    5348 
    5349 
    5350 
    5351 
    5352 
    5353 
    5354 
    5355 
    5356 
    5357 
    5358 
    5359 
    5360 
    5361 
    5362 
    5363 
    5364 
    5365 if test -n "$ac_tool_prefix"; then
    5366   # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
    5367 set dummy ${ac_tool_prefix}dlltool; ac_word=$2
    5368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5369 $as_echo_n "checking for $ac_word... " >&6; }
    5370 if ${ac_cv_prog_DLLTOOL+:} false; then :
    5371   $as_echo_n "(cached) " >&6
    5372 else
    5373   if test -n "$DLLTOOL"; then
    5374   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
    5375 else
    5376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5377 for as_dir in $PATH
    5378 do
    5379   IFS=$as_save_IFS
    5380   test -z "$as_dir" && as_dir=.
    5381     for ac_exec_ext in '' $ac_executable_extensions; do
    5382   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5383     ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
    5384     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5385     break 2
    5386   fi
    5387 done
    5388   done
    5389 IFS=$as_save_IFS
    5390 
    5391 fi
    5392 fi
    5393 DLLTOOL=$ac_cv_prog_DLLTOOL
    5394 if test -n "$DLLTOOL"; then
    5395   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
    5396 $as_echo "$DLLTOOL" >&6; }
    5397 else
    5398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5399 $as_echo "no" >&6; }
    5400 fi
    5401 
    5402 
    5403 fi
    5404 if test -z "$ac_cv_prog_DLLTOOL"; then
    5405   ac_ct_DLLTOOL=$DLLTOOL
    5406   # Extract the first word of "dlltool", so it can be a program name with args.
    5407 set dummy dlltool; ac_word=$2
    5408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5409 $as_echo_n "checking for $ac_word... " >&6; }
    5410 if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
    5411   $as_echo_n "(cached) " >&6
    5412 else
    5413   if test -n "$ac_ct_DLLTOOL"; then
    5414   ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
    5415 else
    5416 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5417 for as_dir in $PATH
    5418 do
    5419   IFS=$as_save_IFS
    5420   test -z "$as_dir" && as_dir=.
    5421     for ac_exec_ext in '' $ac_executable_extensions; do
    5422   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5423     ac_cv_prog_ac_ct_DLLTOOL="dlltool"
    5424     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5425     break 2
    5426   fi
    5427 done
    5428   done
    5429 IFS=$as_save_IFS
    5430 
    5431 fi
    5432 fi
    5433 ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
    5434 if test -n "$ac_ct_DLLTOOL"; then
    5435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
    5436 $as_echo "$ac_ct_DLLTOOL" >&6; }
    5437 else
    5438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5439 $as_echo "no" >&6; }
    5440 fi
    5441 
    5442   if test "x$ac_ct_DLLTOOL" = x; then
    5443     DLLTOOL="false"
    5444   else
    5445     case $cross_compiling:$ac_tool_warned in
    5446 yes:)
    5447 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    5448 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    5449 ac_tool_warned=yes ;;
    5450 esac
    5451     DLLTOOL=$ac_ct_DLLTOOL
    5452   fi
    5453 else
    5454   DLLTOOL="$ac_cv_prog_DLLTOOL"
    5455 fi
    5456 
    5457 test -z "$DLLTOOL" && DLLTOOL=dlltool
    5458 
    5459 
    5460 
    5461 
    5462 
    5463 
    5464 
    5465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
    5466 $as_echo_n "checking how to associate runtime and link libraries... " >&6; }
    5467 if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then :
    5468   $as_echo_n "(cached) " >&6
    5469 else
    5470   lt_cv_sharedlib_from_linklib_cmd='unknown'
    5471 
    5472 case $host_os in
    5473 cygwin* | mingw* | pw32* | cegcc*)
    5474   # two different shell functions defined in ltmain.sh;
    5475   # decide which one to use based on capabilities of $DLLTOOL
    5476   case `$DLLTOOL --help 2>&1` in
    5477   *--identify-strict*)
    5478     lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
    5479     ;;
    5480   *)
    5481     lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
    5482     ;;
    5483   esac
    5484   ;;
    5485 *)
    5486   # fallback: assume linklib IS sharedlib
    5487   lt_cv_sharedlib_from_linklib_cmd=$ECHO
    5488   ;;
    5489 esac
    5490 
    5491 fi
    5492 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
    5493 $as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
    5494 sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
    5495 test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
    5496 
    5497 
    5498 
    5499 
    5500 
    5501 
    5502 
    5503 
    5504 if test -n "$ac_tool_prefix"; then
    5505   for ac_prog in ar
    5506   do
    5507     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    5508 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    5509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5510 $as_echo_n "checking for $ac_word... " >&6; }
    5511 if ${ac_cv_prog_AR+:} false; then :
    5512   $as_echo_n "(cached) " >&6
    5513 else
    5514   if test -n "$AR"; then
    5515   ac_cv_prog_AR="$AR" # Let the user override the test.
    5516 else
    5517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5518 for as_dir in $PATH
    5519 do
    5520   IFS=$as_save_IFS
    5521   test -z "$as_dir" && as_dir=.
    5522     for ac_exec_ext in '' $ac_executable_extensions; do
    5523   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5524     ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
    5525     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5526     break 2
    5527   fi
    5528 done
    5529   done
    5530 IFS=$as_save_IFS
    5531 
    5532 fi
    5533 fi
    5534 AR=$ac_cv_prog_AR
    5535 if test -n "$AR"; then
    5536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
    5537 $as_echo "$AR" >&6; }
    5538 else
    5539   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5540 $as_echo "no" >&6; }
    5541 fi
    5542 
    5543 
    5544     test -n "$AR" && break
    5545   done
    5546 fi
    5547 if test -z "$AR"; then
    5548   ac_ct_AR=$AR
    5549   for ac_prog in ar
    5550 do
    5551   # Extract the first word of "$ac_prog", so it can be a program name with args.
    5552 set dummy $ac_prog; ac_word=$2
    5553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5554 $as_echo_n "checking for $ac_word... " >&6; }
    5555 if ${ac_cv_prog_ac_ct_AR+:} false; then :
    5556   $as_echo_n "(cached) " >&6
    5557 else
    5558   if test -n "$ac_ct_AR"; then
    5559   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
    5560 else
    5561 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5562 for as_dir in $PATH
    5563 do
    5564   IFS=$as_save_IFS
    5565   test -z "$as_dir" && as_dir=.
    5566     for ac_exec_ext in '' $ac_executable_extensions; do
    5567   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5568     ac_cv_prog_ac_ct_AR="$ac_prog"
    5569     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5570     break 2
    5571   fi
    5572 done
    5573   done
    5574 IFS=$as_save_IFS
    5575 
    5576 fi
    5577 fi
    5578 ac_ct_AR=$ac_cv_prog_ac_ct_AR
    5579 if test -n "$ac_ct_AR"; then
    5580   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
    5581 $as_echo "$ac_ct_AR" >&6; }
    5582 else
    5583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5584 $as_echo "no" >&6; }
    5585 fi
    5586 
    5587 
    5588   test -n "$ac_ct_AR" && break
    5589 done
    5590 
    5591   if test "x$ac_ct_AR" = x; then
    5592     AR="false"
    5593   else
    5594     case $cross_compiling:$ac_tool_warned in
    5595 yes:)
    5596 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    5597 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    5598 ac_tool_warned=yes ;;
    5599 esac
    5600     AR=$ac_ct_AR
    5601   fi
    5602 fi
    5603 
    5604 : ${AR=ar}
    5605 : ${AR_FLAGS=cru}
    5606 
    5607 
    5608 
    5609 
    5610 
    5611 
    5612 
    5613 
    5614 
    5615 
    5616 
    5617 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
    5618 $as_echo_n "checking for archiver @FILE support... " >&6; }
    5619 if ${lt_cv_ar_at_file+:} false; then :
    5620   $as_echo_n "(cached) " >&6
    5621 else
    5622   lt_cv_ar_at_file=no
    5623    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    5624 /* end confdefs.h.  */
    5625 
    5626 int
    5627 main ()
    5628 {
    5629 
    5630   ;
    5631   return 0;
    5632 }
    5633 _ACEOF
    5634 if ac_fn_c_try_compile "$LINENO"; then :
    5635   echo conftest.$ac_objext > conftest.lst
    5636       lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
    5637       { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
    5638   (eval $lt_ar_try) 2>&5
    5639   ac_status=$?
    5640   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    5641   test $ac_status = 0; }
    5642       if test 0 -eq "$ac_status"; then
    5643         # Ensure the archiver fails upon bogus file names.
    5644         rm -f conftest.$ac_objext libconftest.a
    5645         { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
    5646   (eval $lt_ar_try) 2>&5
    5647   ac_status=$?
    5648   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    5649   test $ac_status = 0; }
    5650         if test 0 -ne "$ac_status"; then
    5651           lt_cv_ar_at_file=@
    5652         fi
    5653       fi
    5654       rm -f conftest.* libconftest.a
    5655 
    5656 fi
    5657 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5658 
    5659 fi
    5660 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
    5661 $as_echo "$lt_cv_ar_at_file" >&6; }
    5662 
    5663 if test no = "$lt_cv_ar_at_file"; then
    5664   archiver_list_spec=
    5665 else
    5666   archiver_list_spec=$lt_cv_ar_at_file
    5667 fi
    5668 
    5669 
    5670 
    5671 
    5672 
    5673 
    5674 
    5675 if test -n "$ac_tool_prefix"; then
    5676   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
    5677 set dummy ${ac_tool_prefix}strip; ac_word=$2
    5678 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5679 $as_echo_n "checking for $ac_word... " >&6; }
    5680 if ${ac_cv_prog_STRIP+:} false; then :
    5681   $as_echo_n "(cached) " >&6
    5682 else
    5683   if test -n "$STRIP"; then
    5684   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
    5685 else
    5686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5687 for as_dir in $PATH
    5688 do
    5689   IFS=$as_save_IFS
    5690   test -z "$as_dir" && as_dir=.
    5691     for ac_exec_ext in '' $ac_executable_extensions; do
    5692   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5693     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
    5694     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5695     break 2
    5696   fi
    5697 done
    5698   done
    5699 IFS=$as_save_IFS
    5700 
    5701 fi
    5702 fi
    5703 STRIP=$ac_cv_prog_STRIP
    5704 if test -n "$STRIP"; then
    5705   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
    5706 $as_echo "$STRIP" >&6; }
    5707 else
    5708   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5709 $as_echo "no" >&6; }
    5710 fi
    5711 
    5712 
    5713 fi
    5714 if test -z "$ac_cv_prog_STRIP"; then
    5715   ac_ct_STRIP=$STRIP
    5716   # Extract the first word of "strip", so it can be a program name with args.
    5717 set dummy strip; ac_word=$2
    5718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5719 $as_echo_n "checking for $ac_word... " >&6; }
    5720 if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
    5721   $as_echo_n "(cached) " >&6
    5722 else
    5723   if test -n "$ac_ct_STRIP"; then
    5724   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
    5725 else
    5726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5727 for as_dir in $PATH
    5728 do
    5729   IFS=$as_save_IFS
    5730   test -z "$as_dir" && as_dir=.
    5731     for ac_exec_ext in '' $ac_executable_extensions; do
    5732   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5733     ac_cv_prog_ac_ct_STRIP="strip"
    5734     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5735     break 2
    5736   fi
    5737 done
    5738   done
    5739 IFS=$as_save_IFS
    5740 
    5741 fi
    5742 fi
    5743 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
    5744 if test -n "$ac_ct_STRIP"; then
    5745   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
    5746 $as_echo "$ac_ct_STRIP" >&6; }
    5747 else
    5748   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5749 $as_echo "no" >&6; }
    5750 fi
    5751 
    5752   if test "x$ac_ct_STRIP" = x; then
    5753     STRIP=":"
    5754   else
    5755     case $cross_compiling:$ac_tool_warned in
    5756 yes:)
    5757 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    5758 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    5759 ac_tool_warned=yes ;;
    5760 esac
    5761     STRIP=$ac_ct_STRIP
    5762   fi
    5763 else
    5764   STRIP="$ac_cv_prog_STRIP"
    5765 fi
    5766 
    5767 test -z "$STRIP" && STRIP=:
    5768 
    5769 
    5770 
    5771 
    5772 
    5773 
    5774 if test -n "$ac_tool_prefix"; then
    5775   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
    5776 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
    5777 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5778 $as_echo_n "checking for $ac_word... " >&6; }
    5779 if ${ac_cv_prog_RANLIB+:} false; then :
    5780   $as_echo_n "(cached) " >&6
    5781 else
    5782   if test -n "$RANLIB"; then
    5783   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
    5784 else
    5785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5786 for as_dir in $PATH
    5787 do
    5788   IFS=$as_save_IFS
    5789   test -z "$as_dir" && as_dir=.
    5790     for ac_exec_ext in '' $ac_executable_extensions; do
    5791   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5792     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
    5793     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5794     break 2
    5795   fi
    5796 done
    5797   done
    5798 IFS=$as_save_IFS
    5799 
    5800 fi
    5801 fi
    5802 RANLIB=$ac_cv_prog_RANLIB
    5803 if test -n "$RANLIB"; then
    5804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
    5805 $as_echo "$RANLIB" >&6; }
    5806 else
    5807   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5808 $as_echo "no" >&6; }
    5809 fi
    5810 
    5811 
    5812 fi
    5813 if test -z "$ac_cv_prog_RANLIB"; then
    5814   ac_ct_RANLIB=$RANLIB
    5815   # Extract the first word of "ranlib", so it can be a program name with args.
    5816 set dummy ranlib; ac_word=$2
    5817 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    5818 $as_echo_n "checking for $ac_word... " >&6; }
    5819 if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
    5820   $as_echo_n "(cached) " >&6
    5821 else
    5822   if test -n "$ac_ct_RANLIB"; then
    5823   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
    5824 else
    5825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5826 for as_dir in $PATH
    5827 do
    5828   IFS=$as_save_IFS
    5829   test -z "$as_dir" && as_dir=.
    5830     for ac_exec_ext in '' $ac_executable_extensions; do
    5831   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    5832     ac_cv_prog_ac_ct_RANLIB="ranlib"
    5833     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    5834     break 2
    5835   fi
    5836 done
    5837   done
    5838 IFS=$as_save_IFS
    5839 
    5840 fi
    5841 fi
    5842 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
    5843 if test -n "$ac_ct_RANLIB"; then
    5844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
    5845 $as_echo "$ac_ct_RANLIB" >&6; }
    5846 else
    5847   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    5848 $as_echo "no" >&6; }
    5849 fi
    5850 
    5851   if test "x$ac_ct_RANLIB" = x; then
    5852     RANLIB=":"
    5853   else
    5854     case $cross_compiling:$ac_tool_warned in
    5855 yes:)
    5856 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    5857 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    5858 ac_tool_warned=yes ;;
    5859 esac
    5860     RANLIB=$ac_ct_RANLIB
    5861   fi
    5862 else
    5863   RANLIB="$ac_cv_prog_RANLIB"
    5864 fi
    5865 
    5866 test -z "$RANLIB" && RANLIB=:
    5867 
    5868 
    5869 
    5870 
    5871 
    5872 
    5873 # Determine commands to create old-style static archives.
    5874 old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
    5875 old_postinstall_cmds='chmod 644 $oldlib'
    5876 old_postuninstall_cmds=
    5877 
    5878 if test -n "$RANLIB"; then
    5879   case $host_os in
    5880   bitrig* | openbsd*)
    5881     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
    5882     ;;
    5883   *)
    5884     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
    5885     ;;
    5886   esac
    5887   old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
    5888 fi
    5889 
    5890 case $host_os in
    5891   darwin*)
    5892     lock_old_archive_extraction=yes ;;
    5893   *)
    5894     lock_old_archive_extraction=no ;;
    5895 esac
    5896 
    5897 
    5898 
    5899 
    5900 
    5901 
    5902 
    5903 
    5904 
    5905 
    5906 
    5907 
    5908 
    5909 
    5910 
    5911 
    5912 
    5913 
    5914 
    5915 
    5916 
    5917 
    5918 
    5919 
    5920 
    5921 
    5922 
    5923 
    5924 
    5925 
    5926 
    5927 
    5928 
    5929 
    5930 
    5931 
    5932 
    5933 
    5934 
    5935 # If no C compiler was specified, use CC.
    5936 LTCC=${LTCC-"$CC"}
    5937 
    5938 # If no C compiler flags were specified, use CFLAGS.
    5939 LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
    5940 
    5941 # Allow CC to be a program name with arguments.
    5942 compiler=$CC
    5943 
    5944 
    5945 # Check for command to grab the raw symbol name followed by C symbol from nm.
    5946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
    5947 $as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
    5948 if ${lt_cv_sys_global_symbol_pipe+:} false; then :
    5949   $as_echo_n "(cached) " >&6
    5950 else
    5951 
    5952 # These are sane defaults that work on at least a few old systems.
    5953 # [They come from Ultrix.  What could be older than Ultrix?!! ;)]
    5954 
    5955 # Character class describing NM global symbol codes.
    5956 symcode='[BCDEGRST]'
    5957 
    5958 # Regexp to match symbols that can be accessed directly from C.
    5959 sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
    5960 
    5961 # Define system-specific variables.
    5962 case $host_os in
    5963 aix*)
    5964   symcode='[BCDT]'
    5965   ;;
    5966 cygwin* | mingw* | pw32* | cegcc*)
    5967   symcode='[ABCDGISTW]'
    5968   ;;
    5969 hpux*)
    5970   if test ia64 = "$host_cpu"; then
    5971     symcode='[ABCDEGRST]'
    5972   fi
    5973   ;;
    5974 irix* | nonstopux*)
    5975   symcode='[BCDEGRST]'
    5976   ;;
    5977 osf*)
    5978   symcode='[BCDEGQRST]'
    5979   ;;
    5980 solaris*)
    5981   symcode='[BDRT]'
    5982   ;;
    5983 sco3.2v5*)
    5984   symcode='[DT]'
    5985   ;;
    5986 sysv4.2uw2*)
    5987   symcode='[DT]'
    5988   ;;
    5989 sysv5* | sco5v6* | unixware* | OpenUNIX*)
    5990   symcode='[ABDT]'
    5991   ;;
    5992 sysv4)
    5993   symcode='[DFNSTU]'
    5994   ;;
    5995 esac
    5996 
    5997 # If we're using GNU nm, then use its standard symbol codes.
    5998 case `$NM -V 2>&1` in
    5999 *GNU* | *'with BFD'*)
    6000   symcode='[ABCDGIRSTW]' ;;
    6001 esac
    6002 
    6003 if test "$lt_cv_nm_interface" = "MS dumpbin"; then
    6004   # Gets list of data symbols to import.
    6005   lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
    6006   # Adjust the below global symbol transforms to fixup imported variables.
    6007   lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
    6008   lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
    6009   lt_c_name_lib_hook="\
    6010   -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
    6011   -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
    6012 else
    6013   # Disable hooks by default.
    6014   lt_cv_sys_global_symbol_to_import=
    6015   lt_cdecl_hook=
    6016   lt_c_name_hook=
    6017   lt_c_name_lib_hook=
    6018 fi
    6019 
    6020 # Transform an extracted symbol line into a proper C declaration.
    6021 # Some systems (esp. on ia64) link data and code symbols differently,
    6022 # so use this general approach.
    6023 lt_cv_sys_global_symbol_to_cdecl="sed -n"\
    6024 $lt_cdecl_hook\
    6025 " -e 's/^T .* \(.*\)$/extern int \1();/p'"\
    6026 " -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
    6027 
    6028 # Transform an extracted symbol line into symbol name and symbol address
    6029 lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
    6030 $lt_c_name_hook\
    6031 " -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
    6032 " -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
    6033 
    6034 # Transform an extracted symbol line into symbol name with lib prefix and
    6035 # symbol address.
    6036 lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
    6037 $lt_c_name_lib_hook\
    6038 " -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
    6039 " -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
    6040 " -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
    6041 
    6042 # Handle CRLF in mingw tool chain
    6043 opt_cr=
    6044 case $build_os in
    6045 mingw*)
    6046   opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
    6047   ;;
    6048 esac
    6049 
    6050 # Try without a prefix underscore, then with it.
    6051 for ac_symprfx in "" "_"; do
    6052 
    6053   # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
    6054   symxfrm="\\1 $ac_symprfx\\2 \\2"
    6055 
    6056   # Write the raw and C identifiers.
    6057   if test "$lt_cv_nm_interface" = "MS dumpbin"; then
    6058     # Fake it for dumpbin and say T for any non-static function,
    6059     # D for any global variable and I for any imported variable.
    6060     # Also find C++ and __fastcall symbols from MSVC++,
    6061     # which start with @ or ?.
    6062     lt_cv_sys_global_symbol_pipe="$AWK '"\
    6063 "     {last_section=section; section=\$ 3};"\
    6064 "     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
    6065 "     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
    6066 "     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
    6067 "     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
    6068 "     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
    6069 "     \$ 0!~/External *\|/{next};"\
    6070 "     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
    6071 "     {if(hide[section]) next};"\
    6072 "     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
    6073 "     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
    6074 "     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
    6075 "     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
    6076 "     ' prfx=^$ac_symprfx"
    6077   else
    6078     lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[      ]\($symcode$symcode*\)[         ][      ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
    6079   fi
    6080   lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
    6081 
    6082   # Check to see that the pipe works correctly.
    6083   pipe_works=no
    6084 
    6085   rm -f conftest*
    6086   cat > conftest.$ac_ext <<_LT_EOF
    6087 #ifdef __cplusplus
    6088 extern "C" {
    6089 #endif
    6090 char nm_test_var;
    6091 void nm_test_func(void);
    6092 void nm_test_func(void){}
    6093 #ifdef __cplusplus
    6094 }
    6095 #endif
    6096 int main(){nm_test_var='a';nm_test_func();return(0);}
    6097 _LT_EOF
    6098 
    6099   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
    6100   (eval $ac_compile) 2>&5
    6101   ac_status=$?
    6102   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6103   test $ac_status = 0; }; then
    6104     # Now try to grab the symbols.
    6105     nlist=conftest.nm
    6106     if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5
    6107   (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5
    6108   ac_status=$?
    6109   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6110   test $ac_status = 0; } && test -s "$nlist"; then
    6111       # Try sorting and uniquifying the output.
    6112       if sort "$nlist" | uniq > "$nlist"T; then
    6113         mv -f "$nlist"T "$nlist"
    6114       else
    6115         rm -f "$nlist"T
    6116       fi
    6117 
    6118       # Make sure that we snagged all the symbols we need.
    6119       if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
    6120         if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
    6121           cat <<_LT_EOF > conftest.$ac_ext
    6122 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
    6123 #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
    6124 /* DATA imports from DLLs on WIN32 can't be const, because runtime
    6125    relocations are performed -- see ld's documentation on pseudo-relocs.  */
    6126 # define LT_DLSYM_CONST
    6127 #elif defined __osf__
    6128 /* This system does not cope well with relocations in const data.  */
    6129 # define LT_DLSYM_CONST
    6130 #else
    6131 # define LT_DLSYM_CONST const
    6132 #endif
    6133 
    6134 #ifdef __cplusplus
    6135 extern "C" {
    6136 #endif
    6137 
    6138 _LT_EOF
    6139           # Now generate the symbol file.
    6140           eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
    6141 
    6142           cat <<_LT_EOF >> conftest.$ac_ext
    6143 
    6144 /* The mapping between symbol names and symbols.  */
    6145 LT_DLSYM_CONST struct {
    6146   const char *name;
    6147   void       *address;
    6148 }
    6149 lt__PROGRAM__LTX_preloaded_symbols[] =
    6150 {
    6151   { "@PROGRAM@", (void *) 0 },
    6152 _LT_EOF
    6153           $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
    6154           cat <<\_LT_EOF >> conftest.$ac_ext
    6155   {0, (void *) 0}
    6156 };
    6157 
    6158 /* This works around a problem in FreeBSD linker */
    6159 #ifdef FREEBSD_WORKAROUND
    6160 static const void *lt_preloaded_setup() {
    6161   return lt__PROGRAM__LTX_preloaded_symbols;
    6162 }
    6163 #endif
    6164 
    6165 #ifdef __cplusplus
    6166 }
    6167 #endif
    6168 _LT_EOF
    6169           # Now try linking the two files.
    6170           mv conftest.$ac_objext conftstm.$ac_objext
    6171           lt_globsym_save_LIBS=$LIBS
    6172           lt_globsym_save_CFLAGS=$CFLAGS
    6173           LIBS=conftstm.$ac_objext
    6174           CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
    6175           if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
    6176   (eval $ac_link) 2>&5
    6177   ac_status=$?
    6178   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6179   test $ac_status = 0; } && test -s conftest$ac_exeext; then
    6180             pipe_works=yes
    6181           fi
    6182           LIBS=$lt_globsym_save_LIBS
    6183           CFLAGS=$lt_globsym_save_CFLAGS
    6184         else
    6185           echo "cannot find nm_test_func in $nlist" >&5
    6186         fi
    6187       else
    6188         echo "cannot find nm_test_var in $nlist" >&5
    6189       fi
    6190     else
    6191       echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
    6192     fi
    6193   else
    6194     echo "$progname: failed program was:" >&5
    6195     cat conftest.$ac_ext >&5
    6196   fi
    6197   rm -rf conftest* conftst*
    6198 
    6199   # Do not use the global_symbol_pipe unless it works.
    6200   if test yes = "$pipe_works"; then
    6201     break
    6202   else
    6203     lt_cv_sys_global_symbol_pipe=
    6204   fi
    6205 done
    6206 
    6207 fi
    6208 
    6209 if test -z "$lt_cv_sys_global_symbol_pipe"; then
    6210   lt_cv_sys_global_symbol_to_cdecl=
    6211 fi
    6212 if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
    6213   { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
    6214 $as_echo "failed" >&6; }
    6215 else
    6216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
    6217 $as_echo "ok" >&6; }
    6218 fi
    6219 
    6220 # Response file support.
    6221 if test "$lt_cv_nm_interface" = "MS dumpbin"; then
    6222   nm_file_list_spec='@'
    6223 elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then
    6224   nm_file_list_spec='@'
    6225 fi
    6226 
    6227 
    6228 
    6229 
    6230 
    6231 
    6232 
    6233 
    6234 
    6235 
    6236 
    6237 
    6238 
    6239 
    6240 
    6241 
    6242 
    6243 
    6244 
    6245 
    6246 
    6247 
    6248 
    6249 
    6250 
    6251 
    6252 
    6253 
    6254 
    6255 
    6256 
    6257 
    6258 
    6259 
    6260 
    6261 
    6262 
    6263 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
    6264 $as_echo_n "checking for sysroot... " >&6; }
    6265 
    6266 # Check whether --with-sysroot was given.
    6267 if test "${with_sysroot+set}" = set; then :
    6268   withval=$with_sysroot;
    6269 else
    6270   with_sysroot=no
    6271 fi
    6272 
    6273 
    6274 lt_sysroot=
    6275 case $with_sysroot in #(
    6276  yes)
    6277    if test yes = "$GCC"; then
    6278      lt_sysroot=`$CC --print-sysroot 2>/dev/null`
    6279    fi
    6280    ;; #(
    6281  /*)
    6282    lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
    6283    ;; #(
    6284  no|'')
    6285    ;; #(
    6286  *)
    6287    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
    6288 $as_echo "$with_sysroot" >&6; }
    6289    as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
    6290    ;;
    6291 esac
    6292 
    6293  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
    6294 $as_echo "${lt_sysroot:-no}" >&6; }
    6295 
    6296 
    6297 
    6298 
    6299 
    6300 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
    6301 $as_echo_n "checking for a working dd... " >&6; }
    6302 if ${ac_cv_path_lt_DD+:} false; then :
    6303   $as_echo_n "(cached) " >&6
    6304 else
    6305   printf 0123456789abcdef0123456789abcdef >conftest.i
    6306 cat conftest.i conftest.i >conftest2.i
    6307 : ${lt_DD:=$DD}
    6308 if test -z "$lt_DD"; then
    6309   ac_path_lt_DD_found=false
    6310   # Loop through the user's path and test for each of PROGNAME-LIST
    6311   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6312 for as_dir in $PATH
    6313 do
    6314   IFS=$as_save_IFS
    6315   test -z "$as_dir" && as_dir=.
    6316     for ac_prog in dd; do
    6317     for ac_exec_ext in '' $ac_executable_extensions; do
    6318       ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext"
    6319       as_fn_executable_p "$ac_path_lt_DD" || continue
    6320 if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
    6321   cmp -s conftest.i conftest.out \
    6322   && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
    6323 fi
    6324       $ac_path_lt_DD_found && break 3
    6325     done
    6326   done
    6327   done
    6328 IFS=$as_save_IFS
    6329   if test -z "$ac_cv_path_lt_DD"; then
    6330     :
    6331   fi
    6332 else
    6333   ac_cv_path_lt_DD=$lt_DD
    6334 fi
    6335 
    6336 rm -f conftest.i conftest2.i conftest.out
    6337 fi
    6338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
    6339 $as_echo "$ac_cv_path_lt_DD" >&6; }
    6340 
    6341 
    6342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
    6343 $as_echo_n "checking how to truncate binary pipes... " >&6; }
    6344 if ${lt_cv_truncate_bin+:} false; then :
    6345   $as_echo_n "(cached) " >&6
    6346 else
    6347   printf 0123456789abcdef0123456789abcdef >conftest.i
    6348 cat conftest.i conftest.i >conftest2.i
    6349 lt_cv_truncate_bin=
    6350 if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
    6351   cmp -s conftest.i conftest.out \
    6352   && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
    6353 fi
    6354 rm -f conftest.i conftest2.i conftest.out
    6355 test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
    6356 fi
    6357 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
    6358 $as_echo "$lt_cv_truncate_bin" >&6; }
    6359 
    6360 
    6361 
    6362 
    6363 
    6364 
    6365 
    6366 # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
    6367 func_cc_basename ()
    6368 {
    6369     for cc_temp in $*""; do
    6370       case $cc_temp in
    6371         compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
    6372         distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
    6373         \-*) ;;
    6374         *) break;;
    6375       esac
    6376     done
    6377     func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
    6378 }
    6379 
    6380 # Check whether --enable-libtool-lock was given.
    6381 if test "${enable_libtool_lock+set}" = set; then :
    6382   enableval=$enable_libtool_lock;
    6383 fi
    6384 
    6385 test no = "$enable_libtool_lock" || enable_libtool_lock=yes
    6386 
    6387 # Some flags need to be propagated to the compiler or linker for good
    6388 # libtool support.
    6389 case $host in
    6390 ia64-*-hpux*)
    6391   # Find out what ABI is being produced by ac_compile, and set mode
    6392   # options accordingly.
    6393   echo 'int i;' > conftest.$ac_ext
    6394   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
    6395   (eval $ac_compile) 2>&5
    6396   ac_status=$?
    6397   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6398   test $ac_status = 0; }; then
    6399     case `/usr/bin/file conftest.$ac_objext` in
    6400       *ELF-32*)
    6401         HPUX_IA64_MODE=32
    6402         ;;
    6403       *ELF-64*)
    6404         HPUX_IA64_MODE=64
    6405         ;;
    6406     esac
    6407   fi
    6408   rm -rf conftest*
    6409   ;;
    6410 *-*-irix6*)
    6411   # Find out what ABI is being produced by ac_compile, and set linker
    6412   # options accordingly.
    6413   echo '#line '$LINENO' "configure"' > conftest.$ac_ext
    6414   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
    6415   (eval $ac_compile) 2>&5
    6416   ac_status=$?
    6417   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6418   test $ac_status = 0; }; then
    6419     if test yes = "$lt_cv_prog_gnu_ld"; then
    6420       case `/usr/bin/file conftest.$ac_objext` in
    6421         *32-bit*)
    6422           LD="${LD-ld} -melf32bsmip"
    6423           ;;
    6424         *N32*)
    6425           LD="${LD-ld} -melf32bmipn32"
    6426           ;;
    6427         *64-bit*)
    6428           LD="${LD-ld} -melf64bmip"
    6429         ;;
    6430       esac
    6431     else
    6432       case `/usr/bin/file conftest.$ac_objext` in
    6433         *32-bit*)
    6434           LD="${LD-ld} -32"
    6435           ;;
    6436         *N32*)
    6437           LD="${LD-ld} -n32"
    6438           ;;
    6439         *64-bit*)
    6440           LD="${LD-ld} -64"
    6441           ;;
    6442       esac
    6443     fi
    6444   fi
    6445   rm -rf conftest*
    6446   ;;
    6447 
    6448 mips64*-*linux*)
    6449   # Find out what ABI is being produced by ac_compile, and set linker
    6450   # options accordingly.
    6451   echo '#line '$LINENO' "configure"' > conftest.$ac_ext
    6452   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
    6453   (eval $ac_compile) 2>&5
    6454   ac_status=$?
    6455   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6456   test $ac_status = 0; }; then
    6457     emul=elf
    6458     case `/usr/bin/file conftest.$ac_objext` in
    6459       *32-bit*)
    6460         emul="${emul}32"
    6461         ;;
    6462       *64-bit*)
    6463         emul="${emul}64"
    6464         ;;
    6465     esac
    6466     case `/usr/bin/file conftest.$ac_objext` in
    6467       *MSB*)
    6468         emul="${emul}btsmip"
    6469         ;;
    6470       *LSB*)
    6471         emul="${emul}ltsmip"
    6472         ;;
    6473     esac
    6474     case `/usr/bin/file conftest.$ac_objext` in
    6475       *N32*)
    6476         emul="${emul}n32"
    6477         ;;
    6478     esac
    6479     LD="${LD-ld} -m $emul"
    6480   fi
    6481   rm -rf conftest*
    6482   ;;
    6483 
    6484 x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
    6485 s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
    6486   # Find out what ABI is being produced by ac_compile, and set linker
    6487   # options accordingly.  Note that the listed cases only cover the
    6488   # situations where additional linker options are needed (such as when
    6489   # doing 32-bit compilation for a host where ld defaults to 64-bit, or
    6490   # vice versa); the common cases where no linker options are needed do
    6491   # not appear in the list.
    6492   echo 'int i;' > conftest.$ac_ext
    6493   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
    6494   (eval $ac_compile) 2>&5
    6495   ac_status=$?
    6496   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6497   test $ac_status = 0; }; then
    6498     case `/usr/bin/file conftest.o` in
    6499       *32-bit*)
    6500         case $host in
    6501           x86_64-*kfreebsd*-gnu)
    6502             LD="${LD-ld} -m elf_i386_fbsd"
    6503             ;;
    6504           x86_64-*linux*)
    6505             case `/usr/bin/file conftest.o` in
    6506               *x86-64*)
    6507                 LD="${LD-ld} -m elf32_x86_64"
    6508                 ;;
    6509               *)
    6510                 LD="${LD-ld} -m elf_i386"
    6511                 ;;
    6512             esac
    6513             ;;
    6514           powerpc64le-*linux*)
    6515             LD="${LD-ld} -m elf32lppclinux"
    6516             ;;
    6517           powerpc64-*linux*)
    6518             LD="${LD-ld} -m elf32ppclinux"
    6519             ;;
    6520           s390x-*linux*)
    6521             LD="${LD-ld} -m elf_s390"
    6522             ;;
    6523           sparc64-*linux*)
    6524             LD="${LD-ld} -m elf32_sparc"
    6525             ;;
    6526         esac
    6527         ;;
    6528       *64-bit*)
    6529         case $host in
    6530           x86_64-*kfreebsd*-gnu)
    6531             LD="${LD-ld} -m elf_x86_64_fbsd"
    6532             ;;
    6533           x86_64-*linux*)
    6534             LD="${LD-ld} -m elf_x86_64"
    6535             ;;
    6536           powerpcle-*linux*)
    6537             LD="${LD-ld} -m elf64lppc"
    6538             ;;
    6539           powerpc-*linux*)
    6540             LD="${LD-ld} -m elf64ppc"
    6541             ;;
    6542           s390*-*linux*|s390*-*tpf*)
    6543             LD="${LD-ld} -m elf64_s390"
    6544             ;;
    6545           sparc*-*linux*)
    6546             LD="${LD-ld} -m elf64_sparc"
    6547             ;;
    6548         esac
    6549         ;;
    6550     esac
    6551   fi
    6552   rm -rf conftest*
    6553   ;;
    6554 
    6555 *-*-sco3.2v5*)
    6556   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
    6557   SAVE_CFLAGS=$CFLAGS
    6558   CFLAGS="$CFLAGS -belf"
    6559   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
    6560 $as_echo_n "checking whether the C compiler needs -belf... " >&6; }
    6561 if ${lt_cv_cc_needs_belf+:} false; then :
    6562   $as_echo_n "(cached) " >&6
    6563 else
    6564   ac_ext=c
    6565 ac_cpp='$CPP $CPPFLAGS'
    6566 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    6567 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    6568 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    6569 
    6570      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    6571 /* end confdefs.h.  */
    6572 
    6573 int
    6574 main ()
    6575 {
    6576 
    6577   ;
    6578   return 0;
    6579 }
    6580 _ACEOF
    6581 if ac_fn_c_try_link "$LINENO"; then :
    6582   lt_cv_cc_needs_belf=yes
    6583 else
    6584   lt_cv_cc_needs_belf=no
    6585 fi
    6586 rm -f core conftest.err conftest.$ac_objext \
    6587     conftest$ac_exeext conftest.$ac_ext
    6588      ac_ext=c
    6589 ac_cpp='$CPP $CPPFLAGS'
    6590 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    6591 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    6592 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    6593 
    6594 fi
    6595 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
    6596 $as_echo "$lt_cv_cc_needs_belf" >&6; }
    6597   if test yes != "$lt_cv_cc_needs_belf"; then
    6598     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
    6599     CFLAGS=$SAVE_CFLAGS
    6600   fi
    6601   ;;
    6602 *-*solaris*)
    6603   # Find out what ABI is being produced by ac_compile, and set linker
    6604   # options accordingly.
    6605   echo 'int i;' > conftest.$ac_ext
    6606   if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
    6607   (eval $ac_compile) 2>&5
    6608   ac_status=$?
    6609   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    6610   test $ac_status = 0; }; then
    6611     case `/usr/bin/file conftest.o` in
    6612     *64-bit*)
    6613       case $lt_cv_prog_gnu_ld in
    6614       yes*)
    6615         case $host in
    6616         i?86-*-solaris*|x86_64-*-solaris*)
    6617           LD="${LD-ld} -m elf_x86_64"
    6618           ;;
    6619         sparc*-*-solaris*)
    6620           LD="${LD-ld} -m elf64_sparc"
    6621           ;;
    6622         esac
    6623         # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
    6624         if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
    6625           LD=${LD-ld}_sol2
    6626         fi
    6627         ;;
    6628       *)
    6629         if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
    6630           LD="${LD-ld} -64"
    6631         fi
    6632         ;;
    6633       esac
    6634       ;;
    6635     esac
    6636   fi
    6637   rm -rf conftest*
    6638   ;;
    6639 esac
    6640 
    6641 need_locks=$enable_libtool_lock
    6642 
    6643 if test -n "$ac_tool_prefix"; then
    6644   # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
    6645 set dummy ${ac_tool_prefix}mt; ac_word=$2
    6646 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6647 $as_echo_n "checking for $ac_word... " >&6; }
    6648 if ${ac_cv_prog_MANIFEST_TOOL+:} false; then :
    6649   $as_echo_n "(cached) " >&6
    6650 else
    6651   if test -n "$MANIFEST_TOOL"; then
    6652   ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
    6653 else
    6654 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6655 for as_dir in $PATH
    6656 do
    6657   IFS=$as_save_IFS
    6658   test -z "$as_dir" && as_dir=.
    6659     for ac_exec_ext in '' $ac_executable_extensions; do
    6660   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6661     ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
    6662     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6663     break 2
    6664   fi
    6665 done
    6666   done
    6667 IFS=$as_save_IFS
    6668 
    6669 fi
    6670 fi
    6671 MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
    6672 if test -n "$MANIFEST_TOOL"; then
    6673   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
    6674 $as_echo "$MANIFEST_TOOL" >&6; }
    6675 else
    6676   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6677 $as_echo "no" >&6; }
    6678 fi
    6679 
    6680 
    6681 fi
    6682 if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
    6683   ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
    6684   # Extract the first word of "mt", so it can be a program name with args.
    6685 set dummy mt; ac_word=$2
    6686 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6687 $as_echo_n "checking for $ac_word... " >&6; }
    6688 if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then :
    6689   $as_echo_n "(cached) " >&6
    6690 else
    6691   if test -n "$ac_ct_MANIFEST_TOOL"; then
    6692   ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
    6693 else
    6694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6695 for as_dir in $PATH
    6696 do
    6697   IFS=$as_save_IFS
    6698   test -z "$as_dir" && as_dir=.
    6699     for ac_exec_ext in '' $ac_executable_extensions; do
    6700   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6701     ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
    6702     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6703     break 2
    6704   fi
    6705 done
    6706   done
    6707 IFS=$as_save_IFS
    6708 
    6709 fi
    6710 fi
    6711 ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
    6712 if test -n "$ac_ct_MANIFEST_TOOL"; then
    6713   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
    6714 $as_echo "$ac_ct_MANIFEST_TOOL" >&6; }
    6715 else
    6716   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6717 $as_echo "no" >&6; }
    6718 fi
    6719 
    6720   if test "x$ac_ct_MANIFEST_TOOL" = x; then
    6721     MANIFEST_TOOL=":"
    6722   else
    6723     case $cross_compiling:$ac_tool_warned in
    6724 yes:)
    6725 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    6726 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    6727 ac_tool_warned=yes ;;
    6728 esac
    6729     MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
    6730   fi
    6731 else
    6732   MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
    6733 fi
    6734 
    6735 test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
    6736 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
    6737 $as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
    6738 if ${lt_cv_path_mainfest_tool+:} false; then :
    6739   $as_echo_n "(cached) " >&6
    6740 else
    6741   lt_cv_path_mainfest_tool=no
    6742   echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
    6743   $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
    6744   cat conftest.err >&5
    6745   if $GREP 'Manifest Tool' conftest.out > /dev/null; then
    6746     lt_cv_path_mainfest_tool=yes
    6747   fi
    6748   rm -f conftest*
    6749 fi
    6750 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
    6751 $as_echo "$lt_cv_path_mainfest_tool" >&6; }
    6752 if test yes != "$lt_cv_path_mainfest_tool"; then
    6753   MANIFEST_TOOL=:
    6754 fi
    6755 
    6756 
    6757 
    6758 
    6759 
    6760 
    6761   case $host_os in
    6762     rhapsody* | darwin*)
    6763     if test -n "$ac_tool_prefix"; then
    6764   # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
    6765 set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
    6766 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6767 $as_echo_n "checking for $ac_word... " >&6; }
    6768 if ${ac_cv_prog_DSYMUTIL+:} false; then :
    6769   $as_echo_n "(cached) " >&6
    6770 else
    6771   if test -n "$DSYMUTIL"; then
    6772   ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
    6773 else
    6774 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6775 for as_dir in $PATH
    6776 do
    6777   IFS=$as_save_IFS
    6778   test -z "$as_dir" && as_dir=.
    6779     for ac_exec_ext in '' $ac_executable_extensions; do
    6780   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6781     ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
    6782     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6783     break 2
    6784   fi
    6785 done
    6786   done
    6787 IFS=$as_save_IFS
    6788 
    6789 fi
    6790 fi
    6791 DSYMUTIL=$ac_cv_prog_DSYMUTIL
    6792 if test -n "$DSYMUTIL"; then
    6793   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
    6794 $as_echo "$DSYMUTIL" >&6; }
    6795 else
    6796   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6797 $as_echo "no" >&6; }
    6798 fi
    6799 
    6800 
    6801 fi
    6802 if test -z "$ac_cv_prog_DSYMUTIL"; then
    6803   ac_ct_DSYMUTIL=$DSYMUTIL
    6804   # Extract the first word of "dsymutil", so it can be a program name with args.
    6805 set dummy dsymutil; ac_word=$2
    6806 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6807 $as_echo_n "checking for $ac_word... " >&6; }
    6808 if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then :
    6809   $as_echo_n "(cached) " >&6
    6810 else
    6811   if test -n "$ac_ct_DSYMUTIL"; then
    6812   ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
    6813 else
    6814 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6815 for as_dir in $PATH
    6816 do
    6817   IFS=$as_save_IFS
    6818   test -z "$as_dir" && as_dir=.
    6819     for ac_exec_ext in '' $ac_executable_extensions; do
    6820   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6821     ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
    6822     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6823     break 2
    6824   fi
    6825 done
    6826   done
    6827 IFS=$as_save_IFS
    6828 
    6829 fi
    6830 fi
    6831 ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
    6832 if test -n "$ac_ct_DSYMUTIL"; then
    6833   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
    6834 $as_echo "$ac_ct_DSYMUTIL" >&6; }
    6835 else
    6836   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6837 $as_echo "no" >&6; }
    6838 fi
    6839 
    6840   if test "x$ac_ct_DSYMUTIL" = x; then
    6841     DSYMUTIL=":"
    6842   else
    6843     case $cross_compiling:$ac_tool_warned in
    6844 yes:)
    6845 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    6846 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    6847 ac_tool_warned=yes ;;
    6848 esac
    6849     DSYMUTIL=$ac_ct_DSYMUTIL
    6850   fi
    6851 else
    6852   DSYMUTIL="$ac_cv_prog_DSYMUTIL"
    6853 fi
    6854 
    6855     if test -n "$ac_tool_prefix"; then
    6856   # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
    6857 set dummy ${ac_tool_prefix}nmedit; ac_word=$2
    6858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6859 $as_echo_n "checking for $ac_word... " >&6; }
    6860 if ${ac_cv_prog_NMEDIT+:} false; then :
    6861   $as_echo_n "(cached) " >&6
    6862 else
    6863   if test -n "$NMEDIT"; then
    6864   ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
    6865 else
    6866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6867 for as_dir in $PATH
    6868 do
    6869   IFS=$as_save_IFS
    6870   test -z "$as_dir" && as_dir=.
    6871     for ac_exec_ext in '' $ac_executable_extensions; do
    6872   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6873     ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
    6874     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6875     break 2
    6876   fi
    6877 done
    6878   done
    6879 IFS=$as_save_IFS
    6880 
    6881 fi
    6882 fi
    6883 NMEDIT=$ac_cv_prog_NMEDIT
    6884 if test -n "$NMEDIT"; then
    6885   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
    6886 $as_echo "$NMEDIT" >&6; }
    6887 else
    6888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6889 $as_echo "no" >&6; }
    6890 fi
    6891 
    6892 
    6893 fi
    6894 if test -z "$ac_cv_prog_NMEDIT"; then
    6895   ac_ct_NMEDIT=$NMEDIT
    6896   # Extract the first word of "nmedit", so it can be a program name with args.
    6897 set dummy nmedit; ac_word=$2
    6898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6899 $as_echo_n "checking for $ac_word... " >&6; }
    6900 if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then :
    6901   $as_echo_n "(cached) " >&6
    6902 else
    6903   if test -n "$ac_ct_NMEDIT"; then
    6904   ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
    6905 else
    6906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6907 for as_dir in $PATH
    6908 do
    6909   IFS=$as_save_IFS
    6910   test -z "$as_dir" && as_dir=.
    6911     for ac_exec_ext in '' $ac_executable_extensions; do
    6912   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6913     ac_cv_prog_ac_ct_NMEDIT="nmedit"
    6914     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6915     break 2
    6916   fi
    6917 done
    6918   done
    6919 IFS=$as_save_IFS
    6920 
    6921 fi
    6922 fi
    6923 ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
    6924 if test -n "$ac_ct_NMEDIT"; then
    6925   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
    6926 $as_echo "$ac_ct_NMEDIT" >&6; }
    6927 else
    6928   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6929 $as_echo "no" >&6; }
    6930 fi
    6931 
    6932   if test "x$ac_ct_NMEDIT" = x; then
    6933     NMEDIT=":"
    6934   else
    6935     case $cross_compiling:$ac_tool_warned in
    6936 yes:)
    6937 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    6938 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    6939 ac_tool_warned=yes ;;
    6940 esac
    6941     NMEDIT=$ac_ct_NMEDIT
    6942   fi
    6943 else
    6944   NMEDIT="$ac_cv_prog_NMEDIT"
    6945 fi
    6946 
    6947     if test -n "$ac_tool_prefix"; then
    6948   # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
    6949 set dummy ${ac_tool_prefix}lipo; ac_word=$2
    6950 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6951 $as_echo_n "checking for $ac_word... " >&6; }
    6952 if ${ac_cv_prog_LIPO+:} false; then :
    6953   $as_echo_n "(cached) " >&6
    6954 else
    6955   if test -n "$LIPO"; then
    6956   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
    6957 else
    6958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6959 for as_dir in $PATH
    6960 do
    6961   IFS=$as_save_IFS
    6962   test -z "$as_dir" && as_dir=.
    6963     for ac_exec_ext in '' $ac_executable_extensions; do
    6964   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    6965     ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
    6966     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    6967     break 2
    6968   fi
    6969 done
    6970   done
    6971 IFS=$as_save_IFS
    6972 
    6973 fi
    6974 fi
    6975 LIPO=$ac_cv_prog_LIPO
    6976 if test -n "$LIPO"; then
    6977   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
    6978 $as_echo "$LIPO" >&6; }
    6979 else
    6980   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    6981 $as_echo "no" >&6; }
    6982 fi
    6983 
    6984 
    6985 fi
    6986 if test -z "$ac_cv_prog_LIPO"; then
    6987   ac_ct_LIPO=$LIPO
    6988   # Extract the first word of "lipo", so it can be a program name with args.
    6989 set dummy lipo; ac_word=$2
    6990 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    6991 $as_echo_n "checking for $ac_word... " >&6; }
    6992 if ${ac_cv_prog_ac_ct_LIPO+:} false; then :
    6993   $as_echo_n "(cached) " >&6
    6994 else
    6995   if test -n "$ac_ct_LIPO"; then
    6996   ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
    6997 else
    6998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6999 for as_dir in $PATH
    7000 do
    7001   IFS=$as_save_IFS
    7002   test -z "$as_dir" && as_dir=.
    7003     for ac_exec_ext in '' $ac_executable_extensions; do
    7004   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7005     ac_cv_prog_ac_ct_LIPO="lipo"
    7006     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7007     break 2
    7008   fi
    7009 done
    7010   done
    7011 IFS=$as_save_IFS
    7012 
    7013 fi
    7014 fi
    7015 ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
    7016 if test -n "$ac_ct_LIPO"; then
    7017   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
    7018 $as_echo "$ac_ct_LIPO" >&6; }
    7019 else
    7020   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7021 $as_echo "no" >&6; }
    7022 fi
    7023 
    7024   if test "x$ac_ct_LIPO" = x; then
    7025     LIPO=":"
    7026   else
    7027     case $cross_compiling:$ac_tool_warned in
    7028 yes:)
    7029 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    7030 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    7031 ac_tool_warned=yes ;;
    7032 esac
    7033     LIPO=$ac_ct_LIPO
    7034   fi
    7035 else
    7036   LIPO="$ac_cv_prog_LIPO"
    7037 fi
    7038 
    7039     if test -n "$ac_tool_prefix"; then
    7040   # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
    7041 set dummy ${ac_tool_prefix}otool; ac_word=$2
    7042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7043 $as_echo_n "checking for $ac_word... " >&6; }
    7044 if ${ac_cv_prog_OTOOL+:} false; then :
    7045   $as_echo_n "(cached) " >&6
    7046 else
    7047   if test -n "$OTOOL"; then
    7048   ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
    7049 else
    7050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7051 for as_dir in $PATH
    7052 do
    7053   IFS=$as_save_IFS
    7054   test -z "$as_dir" && as_dir=.
    7055     for ac_exec_ext in '' $ac_executable_extensions; do
    7056   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7057     ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
    7058     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7059     break 2
    7060   fi
    7061 done
    7062   done
    7063 IFS=$as_save_IFS
    7064 
    7065 fi
    7066 fi
    7067 OTOOL=$ac_cv_prog_OTOOL
    7068 if test -n "$OTOOL"; then
    7069   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
    7070 $as_echo "$OTOOL" >&6; }
    7071 else
    7072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7073 $as_echo "no" >&6; }
    7074 fi
    7075 
    7076 
    7077 fi
    7078 if test -z "$ac_cv_prog_OTOOL"; then
    7079   ac_ct_OTOOL=$OTOOL
    7080   # Extract the first word of "otool", so it can be a program name with args.
    7081 set dummy otool; ac_word=$2
    7082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7083 $as_echo_n "checking for $ac_word... " >&6; }
    7084 if ${ac_cv_prog_ac_ct_OTOOL+:} false; then :
    7085   $as_echo_n "(cached) " >&6
    7086 else
    7087   if test -n "$ac_ct_OTOOL"; then
    7088   ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
    7089 else
    7090 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7091 for as_dir in $PATH
    7092 do
    7093   IFS=$as_save_IFS
    7094   test -z "$as_dir" && as_dir=.
    7095     for ac_exec_ext in '' $ac_executable_extensions; do
    7096   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7097     ac_cv_prog_ac_ct_OTOOL="otool"
    7098     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7099     break 2
    7100   fi
    7101 done
    7102   done
    7103 IFS=$as_save_IFS
    7104 
    7105 fi
    7106 fi
    7107 ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
    7108 if test -n "$ac_ct_OTOOL"; then
    7109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
    7110 $as_echo "$ac_ct_OTOOL" >&6; }
    7111 else
    7112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7113 $as_echo "no" >&6; }
    7114 fi
    7115 
    7116   if test "x$ac_ct_OTOOL" = x; then
    7117     OTOOL=":"
    7118   else
    7119     case $cross_compiling:$ac_tool_warned in
    7120 yes:)
    7121 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    7122 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    7123 ac_tool_warned=yes ;;
    7124 esac
    7125     OTOOL=$ac_ct_OTOOL
    7126   fi
    7127 else
    7128   OTOOL="$ac_cv_prog_OTOOL"
    7129 fi
    7130 
    7131     if test -n "$ac_tool_prefix"; then
    7132   # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
    7133 set dummy ${ac_tool_prefix}otool64; ac_word=$2
    7134 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7135 $as_echo_n "checking for $ac_word... " >&6; }
    7136 if ${ac_cv_prog_OTOOL64+:} false; then :
    7137   $as_echo_n "(cached) " >&6
    7138 else
    7139   if test -n "$OTOOL64"; then
    7140   ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
    7141 else
    7142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7143 for as_dir in $PATH
    7144 do
    7145   IFS=$as_save_IFS
    7146   test -z "$as_dir" && as_dir=.
    7147     for ac_exec_ext in '' $ac_executable_extensions; do
    7148   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7149     ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
    7150     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7151     break 2
    7152   fi
    7153 done
    7154   done
    7155 IFS=$as_save_IFS
    7156 
    7157 fi
    7158 fi
    7159 OTOOL64=$ac_cv_prog_OTOOL64
    7160 if test -n "$OTOOL64"; then
    7161   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
    7162 $as_echo "$OTOOL64" >&6; }
    7163 else
    7164   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7165 $as_echo "no" >&6; }
    7166 fi
    7167 
    7168 
    7169 fi
    7170 if test -z "$ac_cv_prog_OTOOL64"; then
    7171   ac_ct_OTOOL64=$OTOOL64
    7172   # Extract the first word of "otool64", so it can be a program name with args.
    7173 set dummy otool64; ac_word=$2
    7174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7175 $as_echo_n "checking for $ac_word... " >&6; }
    7176 if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then :
    7177   $as_echo_n "(cached) " >&6
    7178 else
    7179   if test -n "$ac_ct_OTOOL64"; then
    7180   ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
    7181 else
    7182 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7183 for as_dir in $PATH
    7184 do
    7185   IFS=$as_save_IFS
    7186   test -z "$as_dir" && as_dir=.
    7187     for ac_exec_ext in '' $ac_executable_extensions; do
    7188   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7189     ac_cv_prog_ac_ct_OTOOL64="otool64"
    7190     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7191     break 2
    7192   fi
    7193 done
    7194   done
    7195 IFS=$as_save_IFS
    7196 
    7197 fi
    7198 fi
    7199 ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
    7200 if test -n "$ac_ct_OTOOL64"; then
    7201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
    7202 $as_echo "$ac_ct_OTOOL64" >&6; }
    7203 else
    7204   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7205 $as_echo "no" >&6; }
    7206 fi
    7207 
    7208   if test "x$ac_ct_OTOOL64" = x; then
    7209     OTOOL64=":"
    7210   else
    7211     case $cross_compiling:$ac_tool_warned in
    7212 yes:)
    7213 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    7214 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    7215 ac_tool_warned=yes ;;
    7216 esac
    7217     OTOOL64=$ac_ct_OTOOL64
    7218   fi
    7219 else
    7220   OTOOL64="$ac_cv_prog_OTOOL64"
    7221 fi
    7222 
    7223 
    7224 
    7225 
    7226 
    7227 
    7228 
    7229 
    7230 
    7231 
    7232 
    7233 
    7234 
    7235 
    7236 
    7237 
    7238 
    7239 
    7240 
    7241 
    7242 
    7243 
    7244 
    7245 
    7246 
    7247 
    7248 
    7249     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
    7250 $as_echo_n "checking for -single_module linker flag... " >&6; }
    7251 if ${lt_cv_apple_cc_single_mod+:} false; then :
    7252   $as_echo_n "(cached) " >&6
    7253 else
    7254   lt_cv_apple_cc_single_mod=no
    7255       if test -z "$LT_MULTI_MODULE"; then
    7256         # By default we will add the -single_module flag. You can override
    7257         # by either setting the environment variable LT_MULTI_MODULE
    7258         # non-empty at configure time, or by adding -multi_module to the
    7259         # link flags.
    7260         rm -rf libconftest.dylib*
    7261         echo "int foo(void){return 1;}" > conftest.c
    7262         echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
    7263 -dynamiclib -Wl,-single_module conftest.c" >&5
    7264         $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
    7265           -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
    7266         _lt_result=$?
    7267         # If there is a non-empty error log, and "single_module"
    7268         # appears in it, assume the flag caused a linker warning
    7269         if test -s conftest.err && $GREP single_module conftest.err; then
    7270           cat conftest.err >&5
    7271         # Otherwise, if the output was created with a 0 exit code from
    7272         # the compiler, it worked.
    7273         elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
    7274           lt_cv_apple_cc_single_mod=yes
    7275         else
    7276           cat conftest.err >&5
    7277         fi
    7278         rm -rf libconftest.dylib*
    7279         rm -f conftest.*
    7280       fi
    7281 fi
    7282 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
    7283 $as_echo "$lt_cv_apple_cc_single_mod" >&6; }
    7284 
    7285     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
    7286 $as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
    7287 if ${lt_cv_ld_exported_symbols_list+:} false; then :
    7288   $as_echo_n "(cached) " >&6
    7289 else
    7290   lt_cv_ld_exported_symbols_list=no
    7291       save_LDFLAGS=$LDFLAGS
    7292       echo "_main" > conftest.sym
    7293       LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
    7294       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7295 /* end confdefs.h.  */
    7296 
    7297 int
    7298 main ()
    7299 {
    7300 
    7301   ;
    7302   return 0;
    7303 }
    7304 _ACEOF
    7305 if ac_fn_c_try_link "$LINENO"; then :
    7306   lt_cv_ld_exported_symbols_list=yes
    7307 else
    7308   lt_cv_ld_exported_symbols_list=no
    7309 fi
    7310 rm -f core conftest.err conftest.$ac_objext \
    7311     conftest$ac_exeext conftest.$ac_ext
    7312         LDFLAGS=$save_LDFLAGS
    7313 
    7314 fi
    7315 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
    7316 $as_echo "$lt_cv_ld_exported_symbols_list" >&6; }
    7317 
    7318     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
    7319 $as_echo_n "checking for -force_load linker flag... " >&6; }
    7320 if ${lt_cv_ld_force_load+:} false; then :
    7321   $as_echo_n "(cached) " >&6
    7322 else
    7323   lt_cv_ld_force_load=no
    7324       cat > conftest.c << _LT_EOF
    7325 int forced_loaded() { return 2;}
    7326 _LT_EOF
    7327       echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
    7328       $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
    7329       echo "$AR cru libconftest.a conftest.o" >&5
    7330       $AR cru libconftest.a conftest.o 2>&5
    7331       echo "$RANLIB libconftest.a" >&5
    7332       $RANLIB libconftest.a 2>&5
    7333       cat > conftest.c << _LT_EOF
    7334 int main() { return 0;}
    7335 _LT_EOF
    7336       echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
    7337       $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
    7338       _lt_result=$?
    7339       if test -s conftest.err && $GREP force_load conftest.err; then
    7340         cat conftest.err >&5
    7341       elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
    7342         lt_cv_ld_force_load=yes
    7343       else
    7344         cat conftest.err >&5
    7345       fi
    7346         rm -f conftest.err libconftest.a conftest conftest.c
    7347         rm -rf conftest.dSYM
    7348 
    7349 fi
    7350 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
    7351 $as_echo "$lt_cv_ld_force_load" >&6; }
    7352     case $host_os in
    7353     rhapsody* | darwin1.[012])
    7354       _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
    7355     darwin1.*)
    7356       _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
    7357     darwin*) # darwin 5.x on
    7358       # if running on 10.5 or later, the deployment target defaults
    7359       # to the OS version, if on x86, and 10.4, the deployment
    7360       # target defaults to 10.4. Don't you love it?
    7361       case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
    7362         10.0,*86*-darwin8*|10.0,*-darwin[91]*)
    7363           _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
    7364         10.[012][,.]*)
    7365           _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
    7366         10.*)
    7367           _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
    7368       esac
    7369     ;;
    7370   esac
    7371     if test yes = "$lt_cv_apple_cc_single_mod"; then
    7372       _lt_dar_single_mod='$single_module'
    7373     fi
    7374     if test yes = "$lt_cv_ld_exported_symbols_list"; then
    7375       _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
    7376     else
    7377       _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
    7378     fi
    7379     if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
    7380       _lt_dsymutil='~$DSYMUTIL $lib || :'
    7381     else
    7382       _lt_dsymutil=
    7383     fi
    7384     ;;
    7385   esac
    7386 
    7387 # func_munge_path_list VARIABLE PATH
    7388 # -----------------------------------
    7389 # VARIABLE is name of variable containing _space_ separated list of
    7390 # directories to be munged by the contents of PATH, which is string
    7391 # having a format:
    7392 # "DIR[:DIR]:"
    7393 #       string "DIR[ DIR]" will be prepended to VARIABLE
    7394 # ":DIR[:DIR]"
    7395 #       string "DIR[ DIR]" will be appended to VARIABLE
    7396 # "DIRP[:DIRP]::[DIRA:]DIRA"
    7397 #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
    7398 #       "DIRA[ DIRA]" will be appended to VARIABLE
    7399 # "DIR[:DIR]"
    7400 #       VARIABLE will be replaced by "DIR[ DIR]"
    7401 func_munge_path_list ()
    7402 {
    7403     case x$2 in
    7404     x)
    7405         ;;
    7406     *:)
    7407         eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
    7408         ;;
    7409     x:*)
    7410         eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
    7411         ;;
    7412     *::*)
    7413         eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
    7414         eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
    7415         ;;
    7416     *)
    7417         eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
    7418         ;;
    7419     esac
    7420 }
    7421 
    7422 ac_ext=c
    7423 ac_cpp='$CPP $CPPFLAGS'
    7424 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    7425 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    7426 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    7427 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
    7428 $as_echo_n "checking how to run the C preprocessor... " >&6; }
    7429 # On Suns, sometimes $CPP names a directory.
    7430 if test -n "$CPP" && test -d "$CPP"; then
    7431   CPP=
    7432 fi
    7433 if test -z "$CPP"; then
    7434   if ${ac_cv_prog_CPP+:} false; then :
    7435   $as_echo_n "(cached) " >&6
    7436 else
    7437       # Double quotes because CPP needs to be expanded
    7438     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
    7439     do
    7440       ac_preproc_ok=false
    7441 for ac_c_preproc_warn_flag in '' yes
    7442 do
    7443   # Use a header file that comes with gcc, so configuring glibc
    7444   # with a fresh cross-compiler works.
    7445   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    7446   # <limits.h> exists even on freestanding compilers.
    7447   # On the NeXT, cc -E runs the code through the compiler's parser,
    7448   # not just through cpp. "Syntax error" is here to catch this case.
    7449   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7450 /* end confdefs.h.  */
    7451 #ifdef __STDC__
    7452 # include <limits.h>
    7453 #else
    7454 # include <assert.h>
    7455 #endif
    7456                      Syntax error
    7457 _ACEOF
    7458 if ac_fn_c_try_cpp "$LINENO"; then :
    7459 
    7460 else
    7461   # Broken: fails on valid input.
    7462 continue
    7463 fi
    7464 rm -f conftest.err conftest.i conftest.$ac_ext
    7465 
    7466   # OK, works on sane cases.  Now check whether nonexistent headers
    7467   # can be detected and how.
    7468   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7469 /* end confdefs.h.  */
    7470 #include <ac_nonexistent.h>
    7471 _ACEOF
    7472 if ac_fn_c_try_cpp "$LINENO"; then :
    7473   # Broken: success on invalid input.
    7474 continue
    7475 else
    7476   # Passes both tests.
    7477 ac_preproc_ok=:
    7478 break
    7479 fi
    7480 rm -f conftest.err conftest.i conftest.$ac_ext
    7481 
    7482 done
    7483 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
    7484 rm -f conftest.i conftest.err conftest.$ac_ext
    7485 if $ac_preproc_ok; then :
    7486   break
    7487 fi
    7488 
    7489     done
    7490     ac_cv_prog_CPP=$CPP
    7491 
    7492 fi
    7493   CPP=$ac_cv_prog_CPP
    7494 else
    7495   ac_cv_prog_CPP=$CPP
    7496 fi
    7497 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
    7498 $as_echo "$CPP" >&6; }
    7499 ac_preproc_ok=false
    7500 for ac_c_preproc_warn_flag in '' yes
    7501 do
    7502   # Use a header file that comes with gcc, so configuring glibc
    7503   # with a fresh cross-compiler works.
    7504   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    7505   # <limits.h> exists even on freestanding compilers.
    7506   # On the NeXT, cc -E runs the code through the compiler's parser,
    7507   # not just through cpp. "Syntax error" is here to catch this case.
    7508   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7509 /* end confdefs.h.  */
    7510 #ifdef __STDC__
    7511 # include <limits.h>
    7512 #else
    7513 # include <assert.h>
    7514 #endif
    7515                      Syntax error
    7516 _ACEOF
    7517 if ac_fn_c_try_cpp "$LINENO"; then :
    7518 
    7519 else
    7520   # Broken: fails on valid input.
    7521 continue
    7522 fi
    7523 rm -f conftest.err conftest.i conftest.$ac_ext
    7524 
    7525   # OK, works on sane cases.  Now check whether nonexistent headers
    7526   # can be detected and how.
    7527   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7528 /* end confdefs.h.  */
    7529 #include <ac_nonexistent.h>
    7530 _ACEOF
    7531 if ac_fn_c_try_cpp "$LINENO"; then :
    7532   # Broken: success on invalid input.
    7533 continue
    7534 else
    7535   # Passes both tests.
    7536 ac_preproc_ok=:
    7537 break
    7538 fi
    7539 rm -f conftest.err conftest.i conftest.$ac_ext
    7540 
    7541 done
    7542 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
    7543 rm -f conftest.i conftest.err conftest.$ac_ext
    7544 if $ac_preproc_ok; then :
    7545 
    7546 else
    7547   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    7548 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    7549 as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
    7550 See \`config.log' for more details" "$LINENO" 5; }
    7551 fi
    7552 
    7553 ac_ext=c
    7554 ac_cpp='$CPP $CPPFLAGS'
    7555 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    7556 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    7557 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    7558 
    7559 
    7560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
    7561 $as_echo_n "checking for ANSI C header files... " >&6; }
    7562 if ${ac_cv_header_stdc+:} false; then :
    7563   $as_echo_n "(cached) " >&6
    7564 else
    7565   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7566 /* end confdefs.h.  */
    7567 #include <stdlib.h>
    7568 #include <stdarg.h>
    7569 #include <string.h>
    7570 #include <float.h>
    7571 
    7572 int
    7573 main ()
    7574 {
    7575 
    7576   ;
    7577   return 0;
    7578 }
    7579 _ACEOF
    7580 if ac_fn_c_try_compile "$LINENO"; then :
    7581   ac_cv_header_stdc=yes
    7582 else
    7583   ac_cv_header_stdc=no
    7584 fi
    7585 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    7586 
    7587 if test $ac_cv_header_stdc = yes; then
    7588   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
    7589   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7590 /* end confdefs.h.  */
    7591 #include <string.h>
    7592 
    7593 _ACEOF
    7594 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
    7595   $EGREP "memchr" >/dev/null 2>&1; then :
    7596 
    7597 else
    7598   ac_cv_header_stdc=no
    7599 fi
    7600 rm -f conftest*
    7601 
    7602 fi
    7603 
    7604 if test $ac_cv_header_stdc = yes; then
    7605   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
    7606   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7607 /* end confdefs.h.  */
    7608 #include <stdlib.h>
    7609 
    7610 _ACEOF
    7611 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
    7612   $EGREP "free" >/dev/null 2>&1; then :
    7613 
    7614 else
    7615   ac_cv_header_stdc=no
    7616 fi
    7617 rm -f conftest*
    7618 
    7619 fi
    7620 
    7621 if test $ac_cv_header_stdc = yes; then
    7622   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
    7623   if test "$cross_compiling" = yes; then :
    7624   :
    7625 else
    7626   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    7627 /* end confdefs.h.  */
    7628 #include <ctype.h>
    7629 #include <stdlib.h>
    7630 #if ((' ' & 0x0FF) == 0x020)
    7631 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
    7632 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
    7633 #else
    7634 # define ISLOWER(c) \
    7635                    (('a' <= (c) && (c) <= 'i') \
    7636                      || ('j' <= (c) && (c) <= 'r') \
    7637                      || ('s' <= (c) && (c) <= 'z'))
    7638 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
    7639 #endif
    7640 
    7641 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
    7642 int
    7643 main ()
    7644 {
    7645   int i;
    7646   for (i = 0; i < 256; i++)
    7647     if (XOR (islower (i), ISLOWER (i))
    7648         || toupper (i) != TOUPPER (i))
    7649       return 2;
    7650   return 0;
    7651 }
    7652 _ACEOF
    7653 if ac_fn_c_try_run "$LINENO"; then :
    7654 
    7655 else
    7656   ac_cv_header_stdc=no
    7657 fi
    7658 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
    7659   conftest.$ac_objext conftest.beam conftest.$ac_ext
    7660 fi
    7661 
    7662 fi
    7663 fi
    7664 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
    7665 $as_echo "$ac_cv_header_stdc" >&6; }
    7666 if test $ac_cv_header_stdc = yes; then
    7667 
    7668 $as_echo "#define STDC_HEADERS 1" >>confdefs.h
    7669 
    7670 fi
    7671 
    7672 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
    7673 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
    7674                   inttypes.h stdint.h unistd.h
    7675 do :
    7676   as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
    7677 ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
    7678 "
    7679 if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
    7680   cat >>confdefs.h <<_ACEOF
    7681 #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
    7682 _ACEOF
    7683 
    7684 fi
    7685 
    7686 done
    7687 
    7688 
    7689 for ac_header in dlfcn.h
    7690 do :
    7691   ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
    7692 "
    7693 if test "x$ac_cv_header_dlfcn_h" = xyes; then :
    7694   cat >>confdefs.h <<_ACEOF
    7695 #define HAVE_DLFCN_H 1
    7696 _ACEOF
    7697 
    7698 fi
    7699 
    7700 done
    7701 
    7702 
    7703 # Create libtool.
    7704 
    7705 
    7706 
    7707 
    7708 
    7709 # Set options
    7710 # Check whether --enable-static was given.
    7711 if test "${enable_static+set}" = set; then :
    7712   enableval=$enable_static; p=${PACKAGE-default}
    7713     case $enableval in
    7714     yes) enable_static=yes ;;
    7715     no) enable_static=no ;;
    7716     *)
    7717      enable_static=no
    7718       # Look at the argument we got.  We use all the common list separators.
    7719       lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
    7720       for pkg in $enableval; do
    7721         IFS=$lt_save_ifs
    7722         if test "X$pkg" = "X$p"; then
    7723           enable_static=yes
    7724         fi
    7725       done
    7726       IFS=$lt_save_ifs
    7727       ;;
    7728     esac
    7729 else
    7730   enable_static=no
    7731 fi
    7732 
    7733 
    7734 
    7735 
    7736 
    7737 
    7738 
    7739 
    7740 # Check whether --with-pic was given.
    7741 if test "${with_pic+set}" = set; then :
    7742   withval=$with_pic; lt_p=${PACKAGE-default}
    7743     case $withval in
    7744     yes|no) pic_mode=$withval ;;
    7745     *)
    7746       pic_mode=default
    7747       # Look at the argument we got.  We use all the common list separators.
    7748       lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
    7749       for lt_pkg in $withval; do
    7750         IFS=$lt_save_ifs
    7751         if test "X$lt_pkg" = "X$lt_p"; then
    7752           pic_mode=yes
    7753         fi
    7754       done
    7755       IFS=$lt_save_ifs
    7756       ;;
    7757     esac
    7758 else
    7759   pic_mode=yes
    7760 fi
    7761 
    7762 
    7763 
    7764 
    7765 
    7766 
    7767 enable_win32_dll=yes
    7768 
    7769 case $host in
    7770 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
    7771   if test -n "$ac_tool_prefix"; then
    7772   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
    7773 set dummy ${ac_tool_prefix}as; ac_word=$2
    7774 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7775 $as_echo_n "checking for $ac_word... " >&6; }
    7776 if ${ac_cv_prog_AS+:} false; then :
    7777   $as_echo_n "(cached) " >&6
    7778 else
    7779   if test -n "$AS"; then
    7780   ac_cv_prog_AS="$AS" # Let the user override the test.
    7781 else
    7782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7783 for as_dir in $PATH
    7784 do
    7785   IFS=$as_save_IFS
    7786   test -z "$as_dir" && as_dir=.
    7787     for ac_exec_ext in '' $ac_executable_extensions; do
    7788   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7789     ac_cv_prog_AS="${ac_tool_prefix}as"
    7790     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7791     break 2
    7792   fi
    7793 done
    7794   done
    7795 IFS=$as_save_IFS
    7796 
    7797 fi
    7798 fi
    7799 AS=$ac_cv_prog_AS
    7800 if test -n "$AS"; then
    7801   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
    7802 $as_echo "$AS" >&6; }
    7803 else
    7804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7805 $as_echo "no" >&6; }
    7806 fi
    7807 
    7808 
    7809 fi
    7810 if test -z "$ac_cv_prog_AS"; then
    7811   ac_ct_AS=$AS
    7812   # Extract the first word of "as", so it can be a program name with args.
    7813 set dummy as; ac_word=$2
    7814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7815 $as_echo_n "checking for $ac_word... " >&6; }
    7816 if ${ac_cv_prog_ac_ct_AS+:} false; then :
    7817   $as_echo_n "(cached) " >&6
    7818 else
    7819   if test -n "$ac_ct_AS"; then
    7820   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
    7821 else
    7822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7823 for as_dir in $PATH
    7824 do
    7825   IFS=$as_save_IFS
    7826   test -z "$as_dir" && as_dir=.
    7827     for ac_exec_ext in '' $ac_executable_extensions; do
    7828   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7829     ac_cv_prog_ac_ct_AS="as"
    7830     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7831     break 2
    7832   fi
    7833 done
    7834   done
    7835 IFS=$as_save_IFS
    7836 
    7837 fi
    7838 fi
    7839 ac_ct_AS=$ac_cv_prog_ac_ct_AS
    7840 if test -n "$ac_ct_AS"; then
    7841   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
    7842 $as_echo "$ac_ct_AS" >&6; }
    7843 else
    7844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7845 $as_echo "no" >&6; }
    7846 fi
    7847 
    7848   if test "x$ac_ct_AS" = x; then
    7849     AS="false"
    7850   else
    7851     case $cross_compiling:$ac_tool_warned in
    7852 yes:)
    7853 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    7854 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    7855 ac_tool_warned=yes ;;
    7856 esac
    7857     AS=$ac_ct_AS
    7858   fi
    7859 else
    7860   AS="$ac_cv_prog_AS"
    7861 fi
    7862 
    7863   if test -n "$ac_tool_prefix"; then
    7864   # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
    7865 set dummy ${ac_tool_prefix}dlltool; ac_word=$2
    7866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7867 $as_echo_n "checking for $ac_word... " >&6; }
    7868 if ${ac_cv_prog_DLLTOOL+:} false; then :
    7869   $as_echo_n "(cached) " >&6
    7870 else
    7871   if test -n "$DLLTOOL"; then
    7872   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
    7873 else
    7874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7875 for as_dir in $PATH
    7876 do
    7877   IFS=$as_save_IFS
    7878   test -z "$as_dir" && as_dir=.
    7879     for ac_exec_ext in '' $ac_executable_extensions; do
    7880   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7881     ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
    7882     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7883     break 2
    7884   fi
    7885 done
    7886   done
    7887 IFS=$as_save_IFS
    7888 
    7889 fi
    7890 fi
    7891 DLLTOOL=$ac_cv_prog_DLLTOOL
    7892 if test -n "$DLLTOOL"; then
    7893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
    7894 $as_echo "$DLLTOOL" >&6; }
    7895 else
    7896   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7897 $as_echo "no" >&6; }
    7898 fi
    7899 
    7900 
    7901 fi
    7902 if test -z "$ac_cv_prog_DLLTOOL"; then
    7903   ac_ct_DLLTOOL=$DLLTOOL
    7904   # Extract the first word of "dlltool", so it can be a program name with args.
    7905 set dummy dlltool; ac_word=$2
    7906 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7907 $as_echo_n "checking for $ac_word... " >&6; }
    7908 if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
    7909   $as_echo_n "(cached) " >&6
    7910 else
    7911   if test -n "$ac_ct_DLLTOOL"; then
    7912   ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
    7913 else
    7914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7915 for as_dir in $PATH
    7916 do
    7917   IFS=$as_save_IFS
    7918   test -z "$as_dir" && as_dir=.
    7919     for ac_exec_ext in '' $ac_executable_extensions; do
    7920   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7921     ac_cv_prog_ac_ct_DLLTOOL="dlltool"
    7922     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7923     break 2
    7924   fi
    7925 done
    7926   done
    7927 IFS=$as_save_IFS
    7928 
    7929 fi
    7930 fi
    7931 ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
    7932 if test -n "$ac_ct_DLLTOOL"; then
    7933   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
    7934 $as_echo "$ac_ct_DLLTOOL" >&6; }
    7935 else
    7936   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7937 $as_echo "no" >&6; }
    7938 fi
    7939 
    7940   if test "x$ac_ct_DLLTOOL" = x; then
    7941     DLLTOOL="false"
    7942   else
    7943     case $cross_compiling:$ac_tool_warned in
    7944 yes:)
    7945 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    7946 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    7947 ac_tool_warned=yes ;;
    7948 esac
    7949     DLLTOOL=$ac_ct_DLLTOOL
    7950   fi
    7951 else
    7952   DLLTOOL="$ac_cv_prog_DLLTOOL"
    7953 fi
    7954 
    7955   if test -n "$ac_tool_prefix"; then
    7956   # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
    7957 set dummy ${ac_tool_prefix}objdump; ac_word=$2
    7958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7959 $as_echo_n "checking for $ac_word... " >&6; }
    7960 if ${ac_cv_prog_OBJDUMP+:} false; then :
    7961   $as_echo_n "(cached) " >&6
    7962 else
    7963   if test -n "$OBJDUMP"; then
    7964   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
    7965 else
    7966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7967 for as_dir in $PATH
    7968 do
    7969   IFS=$as_save_IFS
    7970   test -z "$as_dir" && as_dir=.
    7971     for ac_exec_ext in '' $ac_executable_extensions; do
    7972   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7973     ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
    7974     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7975     break 2
    7976   fi
    7977 done
    7978   done
    7979 IFS=$as_save_IFS
    7980 
    7981 fi
    7982 fi
    7983 OBJDUMP=$ac_cv_prog_OBJDUMP
    7984 if test -n "$OBJDUMP"; then
    7985   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
    7986 $as_echo "$OBJDUMP" >&6; }
    7987 else
    7988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7989 $as_echo "no" >&6; }
    7990 fi
    7991 
    7992 
    7993 fi
    7994 if test -z "$ac_cv_prog_OBJDUMP"; then
    7995   ac_ct_OBJDUMP=$OBJDUMP
    7996   # Extract the first word of "objdump", so it can be a program name with args.
    7997 set dummy objdump; ac_word=$2
    7998 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7999 $as_echo_n "checking for $ac_word... " >&6; }
    8000 if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
    8001   $as_echo_n "(cached) " >&6
    8002 else
    8003   if test -n "$ac_ct_OBJDUMP"; then
    8004   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
    8005 else
    8006 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    8007 for as_dir in $PATH
    8008 do
    8009   IFS=$as_save_IFS
    8010   test -z "$as_dir" && as_dir=.
    8011     for ac_exec_ext in '' $ac_executable_extensions; do
    8012   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    8013     ac_cv_prog_ac_ct_OBJDUMP="objdump"
    8014     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    8015     break 2
    8016   fi
    8017 done
    8018   done
    8019 IFS=$as_save_IFS
    8020 
    8021 fi
    8022 fi
    8023 ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
    8024 if test -n "$ac_ct_OBJDUMP"; then
    8025   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
    8026 $as_echo "$ac_ct_OBJDUMP" >&6; }
    8027 else
    8028   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    8029 $as_echo "no" >&6; }
    8030 fi
    8031 
    8032   if test "x$ac_ct_OBJDUMP" = x; then
    8033     OBJDUMP="false"
    8034   else
    8035     case $cross_compiling:$ac_tool_warned in
    8036 yes:)
    8037 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    8038 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    8039 ac_tool_warned=yes ;;
    8040 esac
    8041     OBJDUMP=$ac_ct_OBJDUMP
    8042   fi
    8043 else
    8044   OBJDUMP="$ac_cv_prog_OBJDUMP"
    8045 fi
    8046 
    8047   ;;
    8048 esac
    8049 
    8050 test -z "$AS" && AS=as
    8051 
    8052 
    8053 
    8054 
    8055 
    8056 test -z "$DLLTOOL" && DLLTOOL=dlltool
    8057 
    8058 
    8059 
    8060 
    8061 
    8062 test -z "$OBJDUMP" && OBJDUMP=objdump
    8063 
    8064 
    8065 
    8066 
    8067 
    8068 
    8069 
    8070         enable_dlopen=no
    8071 
    8072 
    8073 
    8074             # Check whether --enable-shared was given.
    8075 if test "${enable_shared+set}" = set; then :
    8076   enableval=$enable_shared; p=${PACKAGE-default}
    8077     case $enableval in
    8078     yes) enable_shared=yes ;;
    8079     no) enable_shared=no ;;
    8080     *)
    8081       enable_shared=no
    8082       # Look at the argument we got.  We use all the common list separators.
    8083       lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
    8084       for pkg in $enableval; do
    8085         IFS=$lt_save_ifs
    8086         if test "X$pkg" = "X$p"; then
    8087           enable_shared=yes
    8088         fi
    8089       done
    8090       IFS=$lt_save_ifs
    8091       ;;
    8092     esac
    8093 else
    8094   enable_shared=yes
    8095 fi
    8096 
    8097 
    8098 
    8099 
    8100 
    8101 
    8102 
    8103 
    8104 
    8105 
    8106 
    8107   # Check whether --enable-fast-install was given.
    8108 if test "${enable_fast_install+set}" = set; then :
    8109   enableval=$enable_fast_install; p=${PACKAGE-default}
    8110     case $enableval in
    8111     yes) enable_fast_install=yes ;;
    8112     no) enable_fast_install=no ;;
    8113     *)
    8114       enable_fast_install=no
    8115       # Look at the argument we got.  We use all the common list separators.
    8116       lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
    8117       for pkg in $enableval; do
    8118         IFS=$lt_save_ifs
    8119         if test "X$pkg" = "X$p"; then
    8120           enable_fast_install=yes
    8121         fi
    8122       done
    8123       IFS=$lt_save_ifs
    8124       ;;
    8125     esac
    8126 else
    8127   enable_fast_install=yes
    8128 fi
    8129 
    8130 
    8131 
    8132 
    8133 
    8134 
    8135 
    8136 
    8137   shared_archive_member_spec=
    8138 case $host,$enable_shared in
    8139 power*-*-aix[5-9]*,yes)
    8140   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
    8141 $as_echo_n "checking which variant of shared library versioning to provide... " >&6; }
    8142 
    8143 # Check whether --with-aix-soname was given.
    8144 if test "${with_aix_soname+set}" = set; then :
    8145   withval=$with_aix_soname; case $withval in
    8146     aix|svr4|both)
    8147       ;;
    8148     *)
    8149       as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
    8150       ;;
    8151     esac
    8152     lt_cv_with_aix_soname=$with_aix_soname
    8153 else
    8154   if ${lt_cv_with_aix_soname+:} false; then :
    8155   $as_echo_n "(cached) " >&6
    8156 else
    8157   lt_cv_with_aix_soname=aix
    8158 fi
    8159 
    8160     with_aix_soname=$lt_cv_with_aix_soname
    8161 fi
    8162 
    8163   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
    8164 $as_echo "$with_aix_soname" >&6; }
    8165   if test aix != "$with_aix_soname"; then
    8166     # For the AIX way of multilib, we name the shared archive member
    8167     # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
    8168     # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
    8169     # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
    8170     # the AIX toolchain works better with OBJECT_MODE set (default 32).
    8171     if test 64 = "${OBJECT_MODE-32}"; then
    8172       shared_archive_member_spec=shr_64
    8173     else
    8174       shared_archive_member_spec=shr
    8175     fi
    8176   fi
    8177   ;;
    8178 *)
    8179   with_aix_soname=aix
    8180   ;;
    8181 esac
    8182 
    8183 
    8184 
    8185 
    8186 
    8187 
    8188 
    8189 
    8190 
    8191 
    8192 # This can be used to rebuild libtool when needed
    8193 LIBTOOL_DEPS=$ltmain
    8194 
    8195 # Always use our own libtool.
    8196 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
    8197 
    8198 
    8199 
    8200 
    8201 
    8202 
    8203 
    8204 
    8205 
    8206 
    8207 
    8208 
    8209 
    8210 
    8211 
    8212 
    8213 
    8214 
    8215 
    8216 
    8217 
    8218 
    8219 
    8220 
    8221 
    8222 
    8223 
    8224 
    8225 
    8226 
    8227 test -z "$LN_S" && LN_S="ln -s"
    8228 
    8229 
    8230 
    8231 
    8232 
    8233 
    8234 
    8235 
    8236 
    8237 
    8238 
    8239 
    8240 
    8241 
    8242 if test -n "${ZSH_VERSION+set}"; then
    8243    setopt NO_GLOB_SUBST
    8244 fi
    8245 
    8246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
    8247 $as_echo_n "checking for objdir... " >&6; }
    8248 if ${lt_cv_objdir+:} false; then :
    8249   $as_echo_n "(cached) " >&6
    8250 else
    8251   rm -f .libs 2>/dev/null
    8252 mkdir .libs 2>/dev/null
    8253 if test -d .libs; then
    8254   lt_cv_objdir=.libs
    8255 else
    8256   # MS-DOS does not allow filenames that begin with a dot.
    8257   lt_cv_objdir=_libs
    8258 fi
    8259 rmdir .libs 2>/dev/null
    8260 fi
    8261 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
    8262 $as_echo "$lt_cv_objdir" >&6; }
    8263 objdir=$lt_cv_objdir
    8264 
    8265 
    8266 
    8267 
    8268 
    8269 cat >>confdefs.h <<_ACEOF
    8270 #define LT_OBJDIR "$lt_cv_objdir/"
    8271 _ACEOF
    8272 
    8273 
    8274 
    8275 
    8276 case $host_os in
    8277 aix3*)
    8278   # AIX sometimes has problems with the GCC collect2 program.  For some
    8279   # reason, if we set the COLLECT_NAMES environment variable, the problems
    8280   # vanish in a puff of smoke.
    8281   if test set != "${COLLECT_NAMES+set}"; then
    8282     COLLECT_NAMES=
    8283     export COLLECT_NAMES
    8284   fi
    8285   ;;
    8286 esac
    8287 
    8288 # Global variables:
    8289 ofile=libtool
    8290 can_build_shared=yes
    8291 
    8292 # All known linkers require a '.a' archive for static linking (except MSVC,
    8293 # which needs '.lib').
    8294 libext=a
    8295 
    8296 with_gnu_ld=$lt_cv_prog_gnu_ld
    8297 
    8298 old_CC=$CC
    8299 old_CFLAGS=$CFLAGS
    8300 
    8301 # Set sane defaults for various variables
    8302 test -z "$CC" && CC=cc
    8303 test -z "$LTCC" && LTCC=$CC
    8304 test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
    8305 test -z "$LD" && LD=ld
    8306 test -z "$ac_objext" && ac_objext=o
    8307 
    8308 func_cc_basename $compiler
    8309 cc_basename=$func_cc_basename_result
    8310 
    8311 
    8312 # Only perform the check for file, if the check method requires it
    8313 test -z "$MAGIC_CMD" && MAGIC_CMD=file
    8314 case $deplibs_check_method in
    8315 file_magic*)
    8316   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
    8317     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
    8318 $as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
    8319 if ${lt_cv_path_MAGIC_CMD+:} false; then :
    8320   $as_echo_n "(cached) " >&6
    8321 else
    8322   case $MAGIC_CMD in
    8323 [\\/*] |  ?:[\\/]*)
    8324   lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
    8325   ;;
    8326 *)
    8327   lt_save_MAGIC_CMD=$MAGIC_CMD
    8328   lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
    8329   ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
    8330   for ac_dir in $ac_dummy; do
    8331     IFS=$lt_save_ifs
    8332     test -z "$ac_dir" && ac_dir=.
    8333     if test -f "$ac_dir/${ac_tool_prefix}file"; then
    8334       lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file"
    8335       if test -n "$file_magic_test_file"; then
    8336         case $deplibs_check_method in
    8337         "file_magic "*)
    8338           file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
    8339           MAGIC_CMD=$lt_cv_path_MAGIC_CMD
    8340           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
    8341             $EGREP "$file_magic_regex" > /dev/null; then
    8342             :
    8343           else
    8344             cat <<_LT_EOF 1>&2
    8345 
    8346 *** Warning: the command libtool uses to detect shared libraries,
    8347 *** $file_magic_cmd, produces output that libtool cannot recognize.
    8348 *** The result is that libtool may fail to recognize shared libraries
    8349 *** as such.  This will affect the creation of libtool libraries that
    8350 *** depend on shared libraries, but programs linked with such libtool
    8351 *** libraries will work regardless of this problem.  Nevertheless, you
    8352 *** may want to report the problem to your system manager and/or to
    8353 *** bug-libtool@gnu.org
    8354 
    8355 _LT_EOF
    8356           fi ;;
    8357         esac
    8358       fi
    8359       break
    8360     fi
    8361   done
    8362   IFS=$lt_save_ifs
    8363   MAGIC_CMD=$lt_save_MAGIC_CMD
    8364   ;;
    8365 esac
    8366 fi
    8367 
    8368 MAGIC_CMD=$lt_cv_path_MAGIC_CMD
    8369 if test -n "$MAGIC_CMD"; then
    8370   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
    8371 $as_echo "$MAGIC_CMD" >&6; }
    8372 else
    8373   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    8374 $as_echo "no" >&6; }
    8375 fi
    8376 
    8377 
    8378 
    8379 
    8380 
    8381 if test -z "$lt_cv_path_MAGIC_CMD"; then
    8382   if test -n "$ac_tool_prefix"; then
    8383     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
    8384 $as_echo_n "checking for file... " >&6; }
    8385 if ${lt_cv_path_MAGIC_CMD+:} false; then :
    8386   $as_echo_n "(cached) " >&6
    8387 else
    8388   case $MAGIC_CMD in
    8389 [\\/*] |  ?:[\\/]*)
    8390   lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
    8391   ;;
    8392 *)
    8393   lt_save_MAGIC_CMD=$MAGIC_CMD
    8394   lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
    8395   ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
    8396   for ac_dir in $ac_dummy; do
    8397     IFS=$lt_save_ifs
    8398     test -z "$ac_dir" && ac_dir=.
    8399     if test -f "$ac_dir/file"; then
    8400       lt_cv_path_MAGIC_CMD=$ac_dir/"file"
    8401       if test -n "$file_magic_test_file"; then
    8402         case $deplibs_check_method in
    8403         "file_magic "*)
    8404           file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
    8405           MAGIC_CMD=$lt_cv_path_MAGIC_CMD
    8406           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
    8407             $EGREP "$file_magic_regex" > /dev/null; then
    8408             :
    8409           else
    8410             cat <<_LT_EOF 1>&2
    8411 
    8412 *** Warning: the command libtool uses to detect shared libraries,
    8413 *** $file_magic_cmd, produces output that libtool cannot recognize.
    8414 *** The result is that libtool may fail to recognize shared libraries
    8415 *** as such.  This will affect the creation of libtool libraries that
    8416 *** depend on shared libraries, but programs linked with such libtool
    8417 *** libraries will work regardless of this problem.  Nevertheless, you
    8418 *** may want to report the problem to your system manager and/or to
    8419 *** bug-libtool@gnu.org
    8420 
    8421 _LT_EOF
    8422           fi ;;
    8423         esac
    8424       fi
    8425       break
    8426     fi
    8427   done
    8428   IFS=$lt_save_ifs
    8429   MAGIC_CMD=$lt_save_MAGIC_CMD
    8430   ;;
    8431 esac
    8432 fi
    8433 
    8434 MAGIC_CMD=$lt_cv_path_MAGIC_CMD
    8435 if test -n "$MAGIC_CMD"; then
    8436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
    8437 $as_echo "$MAGIC_CMD" >&6; }
    8438 else
    8439   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    8440 $as_echo "no" >&6; }
    8441 fi
    8442 
    8443 
    8444   else
    8445     MAGIC_CMD=:
    8446   fi
    8447 fi
    8448 
    8449   fi
    8450   ;;
    8451 esac
    8452 
    8453 # Use C for the default configuration in the libtool script
    8454 
    8455 lt_save_CC=$CC
    8456 ac_ext=c
    8457 ac_cpp='$CPP $CPPFLAGS'
    8458 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    8459 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    8460 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    8461 
    8462 
    8463 # Source file extension for C test sources.
    8464 ac_ext=c
    8465 
    8466 # Object file extension for compiled C test sources.
    8467 objext=o
    8468 objext=$objext
    8469 
    8470 # Code to be used in simple compile tests
    8471 lt_simple_compile_test_code="int some_variable = 0;"
    8472 
    8473 # Code to be used in simple link tests
    8474 lt_simple_link_test_code='int main(){return(0);}'
    8475 
    8476 
    8477 
    8478 
    8479 
    8480 
    8481 
    8482 # If no C compiler was specified, use CC.
    8483 LTCC=${LTCC-"$CC"}
    8484 
    8485 # If no C compiler flags were specified, use CFLAGS.
    8486 LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
    8487 
    8488 # Allow CC to be a program name with arguments.
    8489 compiler=$CC
    8490 
    8491 # Save the default compiler, since it gets overwritten when the other
    8492 # tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
    8493 compiler_DEFAULT=$CC
    8494 
    8495 # save warnings/boilerplate of simple test code
    8496 ac_outfile=conftest.$ac_objext
    8497 echo "$lt_simple_compile_test_code" >conftest.$ac_ext
    8498 eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
    8499 _lt_compiler_boilerplate=`cat conftest.err`
    8500 $RM conftest*
    8501 
    8502 ac_outfile=conftest.$ac_objext
    8503 echo "$lt_simple_link_test_code" >conftest.$ac_ext
    8504 eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
    8505 _lt_linker_boilerplate=`cat conftest.err`
    8506 $RM -r conftest*
    8507 
    8508 
    8509 if test -n "$compiler"; then
    8510 
    8511 lt_prog_compiler_no_builtin_flag=
    8512 
    8513 if test yes = "$GCC"; then
    8514   case $cc_basename in
    8515   nvcc*)
    8516     lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
    8517   *)
    8518     lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
    8519   esac
    8520 
    8521   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
    8522 $as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
    8523 if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then :
    8524   $as_echo_n "(cached) " >&6
    8525 else
    8526   lt_cv_prog_compiler_rtti_exceptions=no
    8527    ac_outfile=conftest.$ac_objext
    8528    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    8529    lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
    8530    # Insert the option either (1) after the last *FLAGS variable, or
    8531    # (2) before a word containing "conftest.", or (3) at the end.
    8532    # Note that $ac_compile itself does not contain backslashes and begins
    8533    # with a dollar sign (not a hyphen), so the echo should work correctly.
    8534    # The option is referenced via a variable to avoid confusing sed.
    8535    lt_compile=`echo "$ac_compile" | $SED \
    8536    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    8537    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    8538    -e 's:$: $lt_compiler_flag:'`
    8539    (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
    8540    (eval "$lt_compile" 2>conftest.err)
    8541    ac_status=$?
    8542    cat conftest.err >&5
    8543    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    8544    if (exit $ac_status) && test -s "$ac_outfile"; then
    8545      # The compiler can only warn and ignore the option if not recognized
    8546      # So say no if there are warnings other than the usual output.
    8547      $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
    8548      $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
    8549      if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
    8550        lt_cv_prog_compiler_rtti_exceptions=yes
    8551      fi
    8552    fi
    8553    $RM conftest*
    8554 
    8555 fi
    8556 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
    8557 $as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
    8558 
    8559 if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
    8560     lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
    8561 else
    8562     :
    8563 fi
    8564 
    8565 fi
    8566 
    8567 
    8568 
    8569 
    8570 
    8571 
    8572   lt_prog_compiler_wl=
    8573 lt_prog_compiler_pic=
    8574 lt_prog_compiler_static=
    8575 
    8576 
    8577   if test yes = "$GCC"; then
    8578     lt_prog_compiler_wl='-Wl,'
    8579     lt_prog_compiler_static='-static'
    8580 
    8581     case $host_os in
    8582       aix*)
    8583       # All AIX code is PIC.
    8584       if test ia64 = "$host_cpu"; then
    8585         # AIX 5 now supports IA64 processor
    8586         lt_prog_compiler_static='-Bstatic'
    8587       fi
    8588       lt_prog_compiler_pic='-fPIC'
    8589       ;;
    8590 
    8591     amigaos*)
    8592       case $host_cpu in
    8593       powerpc)
    8594             # see comment about AmigaOS4 .so support
    8595             lt_prog_compiler_pic='-fPIC'
    8596         ;;
    8597       m68k)
    8598             # FIXME: we need at least 68020 code to build shared libraries, but
    8599             # adding the '-m68020' flag to GCC prevents building anything better,
    8600             # like '-m68040'.
    8601             lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
    8602         ;;
    8603       esac
    8604       ;;
    8605 
    8606     beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
    8607       # PIC is the default for these OSes.
    8608       ;;
    8609 
    8610     mingw* | cygwin* | pw32* | os2* | cegcc*)
    8611       # This hack is so that the source file can tell whether it is being
    8612       # built for inclusion in a dll (and should export symbols for example).
    8613       # Although the cygwin gcc ignores -fPIC, still need this for old-style
    8614       # (--disable-auto-import) libraries
    8615       lt_prog_compiler_pic='-DDLL_EXPORT'
    8616       case $host_os in
    8617       os2*)
    8618         lt_prog_compiler_static='$wl-static'
    8619         ;;
    8620       esac
    8621       ;;
    8622 
    8623     darwin* | rhapsody*)
    8624       # PIC is the default on this platform
    8625       # Common symbols not allowed in MH_DYLIB files
    8626       lt_prog_compiler_pic='-fno-common'
    8627       ;;
    8628 
    8629     haiku*)
    8630       # PIC is the default for Haiku.
    8631       # The "-static" flag exists, but is broken.
    8632       lt_prog_compiler_static=
    8633       ;;
    8634 
    8635     hpux*)
    8636       # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
    8637       # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
    8638       # sets the default TLS model and affects inlining.
    8639       case $host_cpu in
    8640       hppa*64*)
    8641         # +Z the default
    8642         ;;
    8643       *)
    8644         lt_prog_compiler_pic='-fPIC'
    8645         ;;
    8646       esac
    8647       ;;
    8648 
    8649     interix[3-9]*)
    8650       # Interix 3.x gcc -fpic/-fPIC options generate broken code.
    8651       # Instead, we relocate shared libraries at runtime.
    8652       ;;
    8653 
    8654     msdosdjgpp*)
    8655       # Just because we use GCC doesn't mean we suddenly get shared libraries
    8656       # on systems that don't support them.
    8657       lt_prog_compiler_can_build_shared=no
    8658       enable_shared=no
    8659       ;;
    8660 
    8661     *nto* | *qnx*)
    8662       # QNX uses GNU C++, but need to define -shared option too, otherwise
    8663       # it will coredump.
    8664       lt_prog_compiler_pic='-fPIC -shared'
    8665       ;;
    8666 
    8667     sysv4*MP*)
    8668       if test -d /usr/nec; then
    8669         lt_prog_compiler_pic=-Kconform_pic
    8670       fi
    8671       ;;
    8672 
    8673     *)
    8674       lt_prog_compiler_pic='-fPIC'
    8675       ;;
    8676     esac
    8677 
    8678     case $cc_basename in
    8679     nvcc*) # Cuda Compiler Driver 2.2
    8680       lt_prog_compiler_wl='-Xlinker '
    8681       if test -n "$lt_prog_compiler_pic"; then
    8682         lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
    8683       fi
    8684       ;;
    8685     esac
    8686   else
    8687     # PORTME Check for flag to pass linker flags through the system compiler.
    8688     case $host_os in
    8689     aix*)
    8690       lt_prog_compiler_wl='-Wl,'
    8691       if test ia64 = "$host_cpu"; then
    8692         # AIX 5 now supports IA64 processor
    8693         lt_prog_compiler_static='-Bstatic'
    8694       else
    8695         lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
    8696       fi
    8697       ;;
    8698 
    8699     darwin* | rhapsody*)
    8700       # PIC is the default on this platform
    8701       # Common symbols not allowed in MH_DYLIB files
    8702       lt_prog_compiler_pic='-fno-common'
    8703       case $cc_basename in
    8704       nagfor*)
    8705         # NAG Fortran compiler
    8706         lt_prog_compiler_wl='-Wl,-Wl,,'
    8707         lt_prog_compiler_pic='-PIC'
    8708         lt_prog_compiler_static='-Bstatic'
    8709         ;;
    8710       esac
    8711       ;;
    8712 
    8713     mingw* | cygwin* | pw32* | os2* | cegcc*)
    8714       # This hack is so that the source file can tell whether it is being
    8715       # built for inclusion in a dll (and should export symbols for example).
    8716       lt_prog_compiler_pic='-DDLL_EXPORT'
    8717       case $host_os in
    8718       os2*)
    8719         lt_prog_compiler_static='$wl-static'
    8720         ;;
    8721       esac
    8722       ;;
    8723 
    8724     hpux9* | hpux10* | hpux11*)
    8725       lt_prog_compiler_wl='-Wl,'
    8726       # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
    8727       # not for PA HP-UX.
    8728       case $host_cpu in
    8729       hppa*64*|ia64*)
    8730         # +Z the default
    8731         ;;
    8732       *)
    8733         lt_prog_compiler_pic='+Z'
    8734         ;;
    8735       esac
    8736       # Is there a better lt_prog_compiler_static that works with the bundled CC?
    8737       lt_prog_compiler_static='$wl-a ${wl}archive'
    8738       ;;
    8739 
    8740     irix5* | irix6* | nonstopux*)
    8741       lt_prog_compiler_wl='-Wl,'
    8742       # PIC (with -KPIC) is the default.
    8743       lt_prog_compiler_static='-non_shared'
    8744       ;;
    8745 
    8746     linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
    8747       case $cc_basename in
    8748       # old Intel for x86_64, which still supported -KPIC.
    8749       ecc*)
    8750         lt_prog_compiler_wl='-Wl,'
    8751         lt_prog_compiler_pic='-KPIC'
    8752         lt_prog_compiler_static='-static'
    8753         ;;
    8754       # icc used to be incompatible with GCC.
    8755       # ICC 10 doesn't accept -KPIC any more.
    8756       icc* | ifort*)
    8757         lt_prog_compiler_wl='-Wl,'
    8758         lt_prog_compiler_pic='-fPIC'
    8759         lt_prog_compiler_static='-static'
    8760         ;;
    8761       # Lahey Fortran 8.1.
    8762       lf95*)
    8763         lt_prog_compiler_wl='-Wl,'
    8764         lt_prog_compiler_pic='--shared'
    8765         lt_prog_compiler_static='--static'
    8766         ;;
    8767       nagfor*)
    8768         # NAG Fortran compiler
    8769         lt_prog_compiler_wl='-Wl,-Wl,,'
    8770         lt_prog_compiler_pic='-PIC'
    8771         lt_prog_compiler_static='-Bstatic'
    8772         ;;
    8773       tcc*)
    8774         # Fabrice Bellard et al's Tiny C Compiler
    8775         lt_prog_compiler_wl='-Wl,'
    8776         lt_prog_compiler_pic='-fPIC'
    8777         lt_prog_compiler_static='-static'
    8778         ;;
    8779       pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
    8780         # Portland Group compilers (*not* the Pentium gcc compiler,
    8781         # which looks to be a dead project)
    8782         lt_prog_compiler_wl='-Wl,'
    8783         lt_prog_compiler_pic='-fpic'
    8784         lt_prog_compiler_static='-Bstatic'
    8785         ;;
    8786       ccc*)
    8787         lt_prog_compiler_wl='-Wl,'
    8788         # All Alpha code is PIC.
    8789         lt_prog_compiler_static='-non_shared'
    8790         ;;
    8791       xl* | bgxl* | bgf* | mpixl*)
    8792         # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
    8793         lt_prog_compiler_wl='-Wl,'
    8794         lt_prog_compiler_pic='-qpic'
    8795         lt_prog_compiler_static='-qstaticlink'
    8796         ;;
    8797       *)
    8798         case `$CC -V 2>&1 | sed 5q` in
    8799         *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
    8800           # Sun Fortran 8.3 passes all unrecognized flags to the linker
    8801           lt_prog_compiler_pic='-KPIC'
    8802           lt_prog_compiler_static='-Bstatic'
    8803           lt_prog_compiler_wl=''
    8804           ;;
    8805         *Sun\ F* | *Sun*Fortran*)
    8806           lt_prog_compiler_pic='-KPIC'
    8807           lt_prog_compiler_static='-Bstatic'
    8808           lt_prog_compiler_wl='-Qoption ld '
    8809           ;;
    8810         *Sun\ C*)
    8811           # Sun C 5.9
    8812           lt_prog_compiler_pic='-KPIC'
    8813           lt_prog_compiler_static='-Bstatic'
    8814           lt_prog_compiler_wl='-Wl,'
    8815           ;;
    8816         *Intel*\ [CF]*Compiler*)
    8817           lt_prog_compiler_wl='-Wl,'
    8818           lt_prog_compiler_pic='-fPIC'
    8819           lt_prog_compiler_static='-static'
    8820           ;;
    8821         *Portland\ Group*)
    8822           lt_prog_compiler_wl='-Wl,'
    8823           lt_prog_compiler_pic='-fpic'
    8824           lt_prog_compiler_static='-Bstatic'
    8825           ;;
    8826         esac
    8827         ;;
    8828       esac
    8829       ;;
    8830 
    8831     newsos6)
    8832       lt_prog_compiler_pic='-KPIC'
    8833       lt_prog_compiler_static='-Bstatic'
    8834       ;;
    8835 
    8836     *nto* | *qnx*)
    8837       # QNX uses GNU C++, but need to define -shared option too, otherwise
    8838       # it will coredump.
    8839       lt_prog_compiler_pic='-fPIC -shared'
    8840       ;;
    8841 
    8842     osf3* | osf4* | osf5*)
    8843       lt_prog_compiler_wl='-Wl,'
    8844       # All OSF/1 code is PIC.
    8845       lt_prog_compiler_static='-non_shared'
    8846       ;;
    8847 
    8848     rdos*)
    8849       lt_prog_compiler_static='-non_shared'
    8850       ;;
    8851 
    8852     solaris*)
    8853       lt_prog_compiler_pic='-KPIC'
    8854       lt_prog_compiler_static='-Bstatic'
    8855       case $cc_basename in
    8856       f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
    8857         lt_prog_compiler_wl='-Qoption ld ';;
    8858       *)
    8859         lt_prog_compiler_wl='-Wl,';;
    8860       esac
    8861       ;;
    8862 
    8863     sunos4*)
    8864       lt_prog_compiler_wl='-Qoption ld '
    8865       lt_prog_compiler_pic='-PIC'
    8866       lt_prog_compiler_static='-Bstatic'
    8867       ;;
    8868 
    8869     sysv4 | sysv4.2uw2* | sysv4.3*)
    8870       lt_prog_compiler_wl='-Wl,'
    8871       lt_prog_compiler_pic='-KPIC'
    8872       lt_prog_compiler_static='-Bstatic'
    8873       ;;
    8874 
    8875     sysv4*MP*)
    8876       if test -d /usr/nec; then
    8877         lt_prog_compiler_pic='-Kconform_pic'
    8878         lt_prog_compiler_static='-Bstatic'
    8879       fi
    8880       ;;
    8881 
    8882     sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
    8883       lt_prog_compiler_wl='-Wl,'
    8884       lt_prog_compiler_pic='-KPIC'
    8885       lt_prog_compiler_static='-Bstatic'
    8886       ;;
    8887 
    8888     unicos*)
    8889       lt_prog_compiler_wl='-Wl,'
    8890       lt_prog_compiler_can_build_shared=no
    8891       ;;
    8892 
    8893     uts4*)
    8894       lt_prog_compiler_pic='-pic'
    8895       lt_prog_compiler_static='-Bstatic'
    8896       ;;
    8897 
    8898     *)
    8899       lt_prog_compiler_can_build_shared=no
    8900       ;;
    8901     esac
    8902   fi
    8903 
    8904 case $host_os in
    8905   # For platforms that do not support PIC, -DPIC is meaningless:
    8906   *djgpp*)
    8907     lt_prog_compiler_pic=
    8908     ;;
    8909   *)
    8910     lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
    8911     ;;
    8912 esac
    8913 
    8914 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
    8915 $as_echo_n "checking for $compiler option to produce PIC... " >&6; }
    8916 if ${lt_cv_prog_compiler_pic+:} false; then :
    8917   $as_echo_n "(cached) " >&6
    8918 else
    8919   lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
    8920 fi
    8921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
    8922 $as_echo "$lt_cv_prog_compiler_pic" >&6; }
    8923 lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
    8924 
    8925 #
    8926 # Check to make sure the PIC flag actually works.
    8927 #
    8928 if test -n "$lt_prog_compiler_pic"; then
    8929   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
    8930 $as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
    8931 if ${lt_cv_prog_compiler_pic_works+:} false; then :
    8932   $as_echo_n "(cached) " >&6
    8933 else
    8934   lt_cv_prog_compiler_pic_works=no
    8935    ac_outfile=conftest.$ac_objext
    8936    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    8937    lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
    8938    # Insert the option either (1) after the last *FLAGS variable, or
    8939    # (2) before a word containing "conftest.", or (3) at the end.
    8940    # Note that $ac_compile itself does not contain backslashes and begins
    8941    # with a dollar sign (not a hyphen), so the echo should work correctly.
    8942    # The option is referenced via a variable to avoid confusing sed.
    8943    lt_compile=`echo "$ac_compile" | $SED \
    8944    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    8945    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    8946    -e 's:$: $lt_compiler_flag:'`
    8947    (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
    8948    (eval "$lt_compile" 2>conftest.err)
    8949    ac_status=$?
    8950    cat conftest.err >&5
    8951    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    8952    if (exit $ac_status) && test -s "$ac_outfile"; then
    8953      # The compiler can only warn and ignore the option if not recognized
    8954      # So say no if there are warnings other than the usual output.
    8955      $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
    8956      $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
    8957      if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
    8958        lt_cv_prog_compiler_pic_works=yes
    8959      fi
    8960    fi
    8961    $RM conftest*
    8962 
    8963 fi
    8964 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
    8965 $as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
    8966 
    8967 if test yes = "$lt_cv_prog_compiler_pic_works"; then
    8968     case $lt_prog_compiler_pic in
    8969      "" | " "*) ;;
    8970      *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
    8971      esac
    8972 else
    8973     lt_prog_compiler_pic=
    8974      lt_prog_compiler_can_build_shared=no
    8975 fi
    8976 
    8977 fi
    8978 
    8979 
    8980 
    8981 
    8982 
    8983 
    8984 
    8985 
    8986 
    8987 
    8988 
    8989 #
    8990 # Check to make sure the static flag actually works.
    8991 #
    8992 wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
    8993 { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
    8994 $as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
    8995 if ${lt_cv_prog_compiler_static_works+:} false; then :
    8996   $as_echo_n "(cached) " >&6
    8997 else
    8998   lt_cv_prog_compiler_static_works=no
    8999    save_LDFLAGS=$LDFLAGS
    9000    LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
    9001    echo "$lt_simple_link_test_code" > conftest.$ac_ext
    9002    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
    9003      # The linker can only warn and ignore the option if not recognized
    9004      # So say no if there are warnings
    9005      if test -s conftest.err; then
    9006        # Append any errors to the config.log.
    9007        cat conftest.err 1>&5
    9008        $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
    9009        $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
    9010        if diff conftest.exp conftest.er2 >/dev/null; then
    9011          lt_cv_prog_compiler_static_works=yes
    9012        fi
    9013      else
    9014        lt_cv_prog_compiler_static_works=yes
    9015      fi
    9016    fi
    9017    $RM -r conftest*
    9018    LDFLAGS=$save_LDFLAGS
    9019 
    9020 fi
    9021 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
    9022 $as_echo "$lt_cv_prog_compiler_static_works" >&6; }
    9023 
    9024 if test yes = "$lt_cv_prog_compiler_static_works"; then
    9025     :
    9026 else
    9027     lt_prog_compiler_static=
    9028 fi
    9029 
    9030 
    9031 
    9032 
    9033 
    9034 
    9035 
    9036   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
    9037 $as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
    9038 if ${lt_cv_prog_compiler_c_o+:} false; then :
    9039   $as_echo_n "(cached) " >&6
    9040 else
    9041   lt_cv_prog_compiler_c_o=no
    9042    $RM -r conftest 2>/dev/null
    9043    mkdir conftest
    9044    cd conftest
    9045    mkdir out
    9046    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    9047 
    9048    lt_compiler_flag="-o out/conftest2.$ac_objext"
    9049    # Insert the option either (1) after the last *FLAGS variable, or
    9050    # (2) before a word containing "conftest.", or (3) at the end.
    9051    # Note that $ac_compile itself does not contain backslashes and begins
    9052    # with a dollar sign (not a hyphen), so the echo should work correctly.
    9053    lt_compile=`echo "$ac_compile" | $SED \
    9054    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    9055    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    9056    -e 's:$: $lt_compiler_flag:'`
    9057    (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
    9058    (eval "$lt_compile" 2>out/conftest.err)
    9059    ac_status=$?
    9060    cat out/conftest.err >&5
    9061    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    9062    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    9063    then
    9064      # The compiler can only warn and ignore the option if not recognized
    9065      # So say no if there are warnings
    9066      $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
    9067      $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
    9068      if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
    9069        lt_cv_prog_compiler_c_o=yes
    9070      fi
    9071    fi
    9072    chmod u+w . 2>&5
    9073    $RM conftest*
    9074    # SGI C++ compiler will create directory out/ii_files/ for
    9075    # template instantiation
    9076    test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
    9077    $RM out/* && rmdir out
    9078    cd ..
    9079    $RM -r conftest
    9080    $RM conftest*
    9081 
    9082 fi
    9083 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
    9084 $as_echo "$lt_cv_prog_compiler_c_o" >&6; }
    9085 
    9086 
    9087 
    9088 
    9089 
    9090 
    9091   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
    9092 $as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
    9093 if ${lt_cv_prog_compiler_c_o+:} false; then :
    9094   $as_echo_n "(cached) " >&6
    9095 else
    9096   lt_cv_prog_compiler_c_o=no
    9097    $RM -r conftest 2>/dev/null
    9098    mkdir conftest
    9099    cd conftest
    9100    mkdir out
    9101    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    9102 
    9103    lt_compiler_flag="-o out/conftest2.$ac_objext"
    9104    # Insert the option either (1) after the last *FLAGS variable, or
    9105    # (2) before a word containing "conftest.", or (3) at the end.
    9106    # Note that $ac_compile itself does not contain backslashes and begins
    9107    # with a dollar sign (not a hyphen), so the echo should work correctly.
    9108    lt_compile=`echo "$ac_compile" | $SED \
    9109    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    9110    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    9111    -e 's:$: $lt_compiler_flag:'`
    9112    (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
    9113    (eval "$lt_compile" 2>out/conftest.err)
    9114    ac_status=$?
    9115    cat out/conftest.err >&5
    9116    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    9117    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    9118    then
    9119      # The compiler can only warn and ignore the option if not recognized
    9120      # So say no if there are warnings
    9121      $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
    9122      $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
    9123      if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
    9124        lt_cv_prog_compiler_c_o=yes
    9125      fi
    9126    fi
    9127    chmod u+w . 2>&5
    9128    $RM conftest*
    9129    # SGI C++ compiler will create directory out/ii_files/ for
    9130    # template instantiation
    9131    test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
    9132    $RM out/* && rmdir out
    9133    cd ..
    9134    $RM -r conftest
    9135    $RM conftest*
    9136 
    9137 fi
    9138 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
    9139 $as_echo "$lt_cv_prog_compiler_c_o" >&6; }
    9140 
    9141 
    9142 
    9143 
    9144 hard_links=nottested
    9145 if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
    9146   # do not overwrite the value of need_locks provided by the user
    9147   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
    9148 $as_echo_n "checking if we can lock with hard links... " >&6; }
    9149   hard_links=yes
    9150   $RM conftest*
    9151   ln conftest.a conftest.b 2>/dev/null && hard_links=no
    9152   touch conftest.a
    9153   ln conftest.a conftest.b 2>&5 || hard_links=no
    9154   ln conftest.a conftest.b 2>/dev/null && hard_links=no
    9155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
    9156 $as_echo "$hard_links" >&6; }
    9157   if test no = "$hard_links"; then
    9158     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
    9159 $as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
    9160     need_locks=warn
    9161   fi
    9162 else
    9163   need_locks=no
    9164 fi
    9165 
    9166 
    9167 
    9168 
    9169 
    9170 
    9171   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
    9172 $as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
    9173 
    9174   runpath_var=
    9175   allow_undefined_flag=
    9176   always_export_symbols=no
    9177   archive_cmds=
    9178   archive_expsym_cmds=
    9179   compiler_needs_object=no
    9180   enable_shared_with_static_runtimes=no
    9181   export_dynamic_flag_spec=
    9182   export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
    9183   hardcode_automatic=no
    9184   hardcode_direct=no
    9185   hardcode_direct_absolute=no
    9186   hardcode_libdir_flag_spec=
    9187   hardcode_libdir_separator=
    9188   hardcode_minus_L=no
    9189   hardcode_shlibpath_var=unsupported
    9190   inherit_rpath=no
    9191   link_all_deplibs=unknown
    9192   module_cmds=
    9193   module_expsym_cmds=
    9194   old_archive_from_new_cmds=
    9195   old_archive_from_expsyms_cmds=
    9196   thread_safe_flag_spec=
    9197   whole_archive_flag_spec=
    9198   # include_expsyms should be a list of space-separated symbols to be *always*
    9199   # included in the symbol list
    9200   include_expsyms=
    9201   # exclude_expsyms can be an extended regexp of symbols to exclude
    9202   # it will be wrapped by ' (' and ')$', so one must not match beginning or
    9203   # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
    9204   # as well as any symbol that contains 'd'.
    9205   exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
    9206   # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
    9207   # platforms (ab)use it in PIC code, but their linkers get confused if
    9208   # the symbol is explicitly referenced.  Since portable code cannot
    9209   # rely on this symbol name, it's probably fine to never include it in
    9210   # preloaded symbol tables.
    9211   # Exclude shared library initialization/finalization symbols.
    9212   extract_expsyms_cmds=
    9213 
    9214   case $host_os in
    9215   cygwin* | mingw* | pw32* | cegcc*)
    9216     # FIXME: the MSVC++ port hasn't been tested in a loooong time
    9217     # When not using gcc, we currently assume that we are using
    9218     # Microsoft Visual C++.
    9219     if test yes != "$GCC"; then
    9220       with_gnu_ld=no
    9221     fi
    9222     ;;
    9223   interix*)
    9224     # we just hope/assume this is gcc and not c89 (= MSVC++)
    9225     with_gnu_ld=yes
    9226     ;;
    9227   openbsd* | bitrig*)
    9228     with_gnu_ld=no
    9229     ;;
    9230   esac
    9231 
    9232   ld_shlibs=yes
    9233 
    9234   # On some targets, GNU ld is compatible enough with the native linker
    9235   # that we're better off using the native interface for both.
    9236   lt_use_gnu_ld_interface=no
    9237   if test yes = "$with_gnu_ld"; then
    9238     case $host_os in
    9239       aix*)
    9240         # The AIX port of GNU ld has always aspired to compatibility
    9241         # with the native linker.  However, as the warning in the GNU ld
    9242         # block says, versions before 2.19.5* couldn't really create working
    9243         # shared libraries, regardless of the interface used.
    9244         case `$LD -v 2>&1` in
    9245           *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
    9246           *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
    9247           *\ \(GNU\ Binutils\)\ [3-9]*) ;;
    9248           *)
    9249             lt_use_gnu_ld_interface=yes
    9250             ;;
    9251         esac
    9252         ;;
    9253       *)
    9254         lt_use_gnu_ld_interface=yes
    9255         ;;
    9256     esac
    9257   fi
    9258 
    9259   if test yes = "$lt_use_gnu_ld_interface"; then
    9260     # If archive_cmds runs LD, not CC, wlarc should be empty
    9261     wlarc='$wl'
    9262 
    9263     # Set some defaults for GNU ld with shared library support. These
    9264     # are reset later if shared libraries are not supported. Putting them
    9265     # here allows them to be overridden if necessary.
    9266     runpath_var=LD_RUN_PATH
    9267     hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
    9268     export_dynamic_flag_spec='$wl--export-dynamic'
    9269     # ancient GNU ld didn't support --whole-archive et. al.
    9270     if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
    9271       whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
    9272     else
    9273       whole_archive_flag_spec=
    9274     fi
    9275     supports_anon_versioning=no
    9276     case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in
    9277       *GNU\ gold*) supports_anon_versioning=yes ;;
    9278       *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
    9279       *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
    9280       *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
    9281       *\ 2.11.*) ;; # other 2.11 versions
    9282       *) supports_anon_versioning=yes ;;
    9283     esac
    9284 
    9285     # See if GNU ld supports shared libraries.
    9286     case $host_os in
    9287     aix[3-9]*)
    9288       # On AIX/PPC, the GNU linker is very broken
    9289       if test ia64 != "$host_cpu"; then
    9290         ld_shlibs=no
    9291         cat <<_LT_EOF 1>&2
    9292 
    9293 *** Warning: the GNU linker, at least up to release 2.19, is reported
    9294 *** to be unable to reliably create shared libraries on AIX.
    9295 *** Therefore, libtool is disabling shared libraries support.  If you
    9296 *** really care for shared libraries, you may want to install binutils
    9297 *** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
    9298 *** You will then need to restart the configuration process.
    9299 
    9300 _LT_EOF
    9301       fi
    9302       ;;
    9303 
    9304     amigaos*)
    9305       case $host_cpu in
    9306       powerpc)
    9307             # see comment about AmigaOS4 .so support
    9308             archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9309             archive_expsym_cmds=''
    9310         ;;
    9311       m68k)
    9312             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)'
    9313             hardcode_libdir_flag_spec='-L$libdir'
    9314             hardcode_minus_L=yes
    9315         ;;
    9316       esac
    9317       ;;
    9318 
    9319     beos*)
    9320       if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
    9321         allow_undefined_flag=unsupported
    9322         # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
    9323         # support --undefined.  This deserves some investigation.  FIXME
    9324         archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9325       else
    9326         ld_shlibs=no
    9327       fi
    9328       ;;
    9329 
    9330     cygwin* | mingw* | pw32* | cegcc*)
    9331       # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
    9332       # as there is no search path for DLLs.
    9333       hardcode_libdir_flag_spec='-L$libdir'
    9334       export_dynamic_flag_spec='$wl--export-all-symbols'
    9335       allow_undefined_flag=unsupported
    9336       always_export_symbols=no
    9337       enable_shared_with_static_runtimes=yes
    9338       export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
    9339       exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
    9340 
    9341       if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
    9342         archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
    9343         # If the export-symbols file already is a .def file, use it as
    9344         # is; otherwise, prepend EXPORTS...
    9345         archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[   ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([     ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
    9346           cp $export_symbols $output_objdir/$soname.def;
    9347         else
    9348           echo EXPORTS > $output_objdir/$soname.def;
    9349           cat $export_symbols >> $output_objdir/$soname.def;
    9350         fi~
    9351         $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
    9352       else
    9353         ld_shlibs=no
    9354       fi
    9355       ;;
    9356 
    9357     haiku*)
    9358       archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9359       link_all_deplibs=yes
    9360       ;;
    9361 
    9362     os2*)
    9363       hardcode_libdir_flag_spec='-L$libdir'
    9364       hardcode_minus_L=yes
    9365       allow_undefined_flag=unsupported
    9366       shrext_cmds=.dll
    9367       archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
    9368         $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
    9369         $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
    9370         $ECHO EXPORTS >> $output_objdir/$libname.def~
    9371         emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
    9372         $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
    9373         emximp -o $lib $output_objdir/$libname.def'
    9374       archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
    9375         $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
    9376         $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
    9377         $ECHO EXPORTS >> $output_objdir/$libname.def~
    9378         prefix_cmds="$SED"~
    9379         if test EXPORTS = "`$SED 1q $export_symbols`"; then
    9380           prefix_cmds="$prefix_cmds -e 1d";
    9381         fi~
    9382         prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
    9383         cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
    9384         $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
    9385         emximp -o $lib $output_objdir/$libname.def'
    9386       old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
    9387       enable_shared_with_static_runtimes=yes
    9388       ;;
    9389 
    9390     interix[3-9]*)
    9391       hardcode_direct=no
    9392       hardcode_shlibpath_var=no
    9393       hardcode_libdir_flag_spec='$wl-rpath,$libdir'
    9394       export_dynamic_flag_spec='$wl-E'
    9395       # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
    9396       # Instead, shared libraries are loaded at an image base (0x10000000 by
    9397       # default) and relocated if they conflict, which is a slow very memory
    9398       # consuming and fragmenting process.  To avoid this, we pick a random,
    9399       # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
    9400       # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
    9401       archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
    9402       archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
    9403       ;;
    9404 
    9405     gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
    9406       tmp_diet=no
    9407       if test linux-dietlibc = "$host_os"; then
    9408         case $cc_basename in
    9409           diet\ *) tmp_diet=yes;;       # linux-dietlibc with static linking (!diet-dyn)
    9410         esac
    9411       fi
    9412       if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
    9413          && test no = "$tmp_diet"
    9414       then
    9415         tmp_addflag=' $pic_flag'
    9416         tmp_sharedflag='-shared'
    9417         case $cc_basename,$host_cpu in
    9418         pgcc*)                          # Portland Group C compiler
    9419           whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
    9420           tmp_addflag=' $pic_flag'
    9421           ;;
    9422         pgf77* | pgf90* | pgf95* | pgfortran*)
    9423                                         # Portland Group f77 and f90 compilers
    9424           whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
    9425           tmp_addflag=' $pic_flag -Mnomain' ;;
    9426         ecc*,ia64* | icc*,ia64*)        # Intel C compiler on ia64
    9427           tmp_addflag=' -i_dynamic' ;;
    9428         efc*,ia64* | ifort*,ia64*)      # Intel Fortran compiler on ia64
    9429           tmp_addflag=' -i_dynamic -nofor_main' ;;
    9430         ifc* | ifort*)                  # Intel Fortran compiler
    9431           tmp_addflag=' -nofor_main' ;;
    9432         lf95*)                          # Lahey Fortran 8.1
    9433           whole_archive_flag_spec=
    9434           tmp_sharedflag='--shared' ;;
    9435         nagfor*)                        # NAGFOR 5.3
    9436           tmp_sharedflag='-Wl,-shared' ;;
    9437         xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
    9438           tmp_sharedflag='-qmkshrobj'
    9439           tmp_addflag= ;;
    9440         nvcc*)  # Cuda Compiler Driver 2.2
    9441           whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
    9442           compiler_needs_object=yes
    9443           ;;
    9444         esac
    9445         case `$CC -V 2>&1 | sed 5q` in
    9446         *Sun\ C*)                       # Sun C 5.9
    9447           whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
    9448           compiler_needs_object=yes
    9449           tmp_sharedflag='-G' ;;
    9450         *Sun\ F*)                       # Sun Fortran 8.3
    9451           tmp_sharedflag='-G' ;;
    9452         esac
    9453         archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9454 
    9455         if test yes = "$supports_anon_versioning"; then
    9456           archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
    9457             cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
    9458             echo "local: *; };" >> $output_objdir/$libname.ver~
    9459             $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
    9460         fi
    9461 
    9462         case $cc_basename in
    9463         tcc*)
    9464           export_dynamic_flag_spec='-rdynamic'
    9465           ;;
    9466         xlf* | bgf* | bgxlf* | mpixlf*)
    9467           # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
    9468           whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
    9469           hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
    9470           archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
    9471           if test yes = "$supports_anon_versioning"; then
    9472             archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
    9473               cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
    9474               echo "local: *; };" >> $output_objdir/$libname.ver~
    9475               $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
    9476           fi
    9477           ;;
    9478         esac
    9479       else
    9480         ld_shlibs=no
    9481       fi
    9482       ;;
    9483 
    9484     netbsd*)
    9485       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
    9486         archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
    9487         wlarc=
    9488       else
    9489         archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9490         archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
    9491       fi
    9492       ;;
    9493 
    9494     solaris*)
    9495       if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
    9496         ld_shlibs=no
    9497         cat <<_LT_EOF 1>&2
    9498 
    9499 *** Warning: The releases 2.8.* of the GNU linker cannot reliably
    9500 *** create shared libraries on Solaris systems.  Therefore, libtool
    9501 *** is disabling shared libraries support.  We urge you to upgrade GNU
    9502 *** binutils to release 2.9.1 or newer.  Another option is to modify
    9503 *** your PATH or compiler configuration so that the native linker is
    9504 *** used, and then restart.
    9505 
    9506 _LT_EOF
    9507       elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
    9508         archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9509         archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
    9510       else
    9511         ld_shlibs=no
    9512       fi
    9513       ;;
    9514 
    9515     sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
    9516       case `$LD -v 2>&1` in
    9517         *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
    9518         ld_shlibs=no
    9519         cat <<_LT_EOF 1>&2
    9520 
    9521 *** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
    9522 *** reliably create shared libraries on SCO systems.  Therefore, libtool
    9523 *** is disabling shared libraries support.  We urge you to upgrade GNU
    9524 *** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
    9525 *** your PATH or compiler configuration so that the native linker is
    9526 *** used, and then restart.
    9527 
    9528 _LT_EOF
    9529         ;;
    9530         *)
    9531           # For security reasons, it is highly recommended that you always
    9532           # use absolute paths for naming shared libraries, and exclude the
    9533           # DT_RUNPATH tag from executables and libraries.  But doing so
    9534           # requires that you compile everything twice, which is a pain.
    9535           if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
    9536             hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
    9537             archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
    9538             archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
    9539           else
    9540             ld_shlibs=no
    9541           fi
    9542         ;;
    9543       esac
    9544       ;;
    9545 
    9546     sunos4*)
    9547       archive_cmds='$LD -asse