Changes in / [7b61ce8:1f690b3]


Ignore:
Files:
9 added
18 edited

Legend:

Unmodified
Added
Removed
  • benchmark/Makefile.in

    r7b61ce8 r1f690b3  
    260260AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
    261261CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
     262LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
     263        $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
     264        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
     265        $(AM_CFLAGS) $(CFLAGS)
     266
    262267AM_V_CFA = $(am__v_CFA_@AM_V@)
    263268am__v_CFA_ = $(am__v_CFA_@AM_DEFAULT_V@)
     
    287292
    288293.SUFFIXES:
    289 .SUFFIXES: .cfa .o
     294.SUFFIXES: .cfa .lo .o
    290295$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(top_srcdir)/src/cfa.make $(am__configure_deps)
    291296        @for dep in $?; do \
     
    480485        $(am__mv) $$depbase.Tpo $$depbase.Po
    481486
     487.cfa.lo:
     488        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
     489        $(LTCFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
     490        $(am__mv) $$depbase.Tpo $$depbase.Plo
     491
    482492.NOTPARALLEL:
    483493
  • configure

    r7b61ce8 r1f690b3  
    34943494        echo -n "${LIBCFA_PATHS} " >> ${lib_dir}/config.data
    34953495        echo -n "ARCHITECTURE=${lib_arch} " >> ${lib_dir}/config.data
    3496         echo -n "CONFIGURATION=${lib_config}" >> ${lib_dir}/config.data
     3496        echo -n "CONFIGURATION=${lib_config} " >> ${lib_dir}/config.data
     3497        echo -n "CFA_VERSION=${ver_major}:${ver_minor}:${ver_patch}" >> ${lib_dir}/config.data
    34973498done
    34983499
  • configure.ac

    r7b61ce8 r1f690b3  
    172172        echo -n "${LIBCFA_PATHS} " >> ${lib_dir}/config.data
    173173        echo -n "ARCHITECTURE=${lib_arch} " >> ${lib_dir}/config.data
    174         echo -n "CONFIGURATION=${lib_config}" >> ${lib_dir}/config.data
     174        echo -n "CONFIGURATION=${lib_config} " >> ${lib_dir}/config.data
     175        echo -n "CFA_VERSION=${ver_major}:${ver_minor}:${ver_patch}" >> ${lib_dir}/config.data
    175176done
    176177
  • driver/cfa.cc

    r7b61ce8 r1f690b3  
    403403
    404404                // include the cfa library in case it's needed
    405                 args[nargs] = ( *new string( string("-L" ) + libdir + (intree ? "/src" : "")) ).c_str();
     405                args[nargs] = ( *new string( string("-L" ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
     406                nargs += 1;
     407                args[nargs] = ( *new string( string("-Wl,-rpath," ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
    406408                nargs += 1;
    407409                args[nargs] = "-lcfa";
  • libcfa/Makefile.am

    r7b61ce8 r1f690b3  
    1616
    1717AUTOMAKE_OPTIONS = foreign # do not require all the GNU file names
     18ACLOCAL_AMFLAGS  = -I automake
    1819SUBDIRS = prelude src      # order important
  • libcfa/Makefile.in

    r7b61ce8 r1f690b3  
    8989PRE_UNINSTALL = :
    9090POST_UNINSTALL = :
     91build_triplet = @build@
     92host_triplet = @host@
    9193subdir = .
    9294ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    93 am__aclocal_m4_deps = $(top_srcdir)/../automake/cfa.m4 \
    94         $(top_srcdir)/configure.ac
     95am__aclocal_m4_deps = $(top_srcdir)/automake/libtool.m4 \
     96        $(top_srcdir)/automake/ltoptions.m4 \
     97        $(top_srcdir)/automake/ltsugar.m4 \
     98        $(top_srcdir)/automake/ltversion.m4 \
     99        $(top_srcdir)/automake/lt~obsolete.m4 \
     100        $(top_srcdir)/../automake/cfa.m4 $(top_srcdir)/configure.ac
    95101am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
    96102        $(ACLOCAL_M4)
     
    158164CSCOPE = cscope
    159165DIST_SUBDIRS = $(SUBDIRS)
    160 am__DIST_COMMON = $(srcdir)/Makefile.in \
    161         $(top_srcdir)/./automake/compile \
    162         $(top_srcdir)/./automake/install-sh \
    163         $(top_srcdir)/./automake/missing ./automake/compile \
    164         ./automake/config.guess ./automake/config.sub \
    165         ./automake/depcomp ./automake/install-sh ./automake/missing
     166am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/automake/compile \
     167        $(top_srcdir)/automake/config.guess \
     168        $(top_srcdir)/automake/config.sub \
     169        $(top_srcdir)/automake/install-sh \
     170        $(top_srcdir)/automake/ltmain.sh \
     171        $(top_srcdir)/automake/missing automake/compile \
     172        automake/config.guess automake/config.sub automake/depcomp \
     173        automake/install-sh automake/ltmain.sh automake/missing
    166174DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    167175distdir = $(PACKAGE)-$(VERSION)
     
    209217AMTAR = @AMTAR@
    210218AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
     219AR = @AR@
    211220ARCHITECTURE = @ARCHITECTURE@
    212221ARCH_FLAGS = @ARCH_FLAGS@
     
    227236CFA_NAME = @CFA_NAME@
    228237CFA_PREFIX = @CFA_PREFIX@
     238CFA_VERSION = @CFA_VERSION@
    229239CFLAGS = @CFLAGS@
    230240CONFIGURATION = @CONFIGURATION@
     
    232242CONFIG_CFAFLAGS = @CONFIG_CFAFLAGS@
    233243CONFIG_CFLAGS = @CONFIG_CFLAGS@
     244CPP = @CPP@
    234245CPPFLAGS = @CPPFLAGS@
    235246CXX = @CXX@
     247CXXCPP = @CXXCPP@
    236248CXXDEPMODE = @CXXDEPMODE@
    237249CXXFLAGS = @CXXFLAGS@
     
    239251DEFS = @DEFS@
    240252DEPDIR = @DEPDIR@
     253DLLTOOL = @DLLTOOL@
    241254DRIVER_DIR = @DRIVER_DIR@
     255DSYMUTIL = @DSYMUTIL@
     256DUMPBIN = @DUMPBIN@
    242257ECHO_C = @ECHO_C@
    243258ECHO_N = @ECHO_N@
    244259ECHO_T = @ECHO_T@
     260EGREP = @EGREP@
    245261EXEEXT = @EXEEXT@
     262FGREP = @FGREP@
     263GREP = @GREP@
    246264INSTALL = @INSTALL@
    247265INSTALL_DATA = @INSTALL_DATA@
     
    249267INSTALL_SCRIPT = @INSTALL_SCRIPT@
    250268INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
     269LD = @LD@
    251270LDFLAGS = @LDFLAGS@
    252271LIBOBJS = @LIBOBJS@
    253272LIBS = @LIBS@
     273LIBTOOL = @LIBTOOL@
     274LIPO = @LIPO@
     275LN_S = @LN_S@
    254276LTLIBOBJS = @LTLIBOBJS@
     277LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
    255278MAKEINFO = @MAKEINFO@
     279MANIFEST_TOOL = @MANIFEST_TOOL@
    256280MKDIR_P = @MKDIR_P@
     281NM = @NM@
     282NMEDIT = @NMEDIT@
     283OBJDUMP = @OBJDUMP@
    257284OBJEXT = @OBJEXT@
     285OTOOL = @OTOOL@
     286OTOOL64 = @OTOOL64@
    258287PACKAGE = @PACKAGE@
    259288PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
     
    265294PATH_SEPARATOR = @PATH_SEPARATOR@
    266295RANLIB = @RANLIB@
     296SED = @SED@
    267297SET_MAKE = @SET_MAKE@
    268298SHELL = @SHELL@
     
    273303abs_top_builddir = @abs_top_builddir@
    274304abs_top_srcdir = @abs_top_srcdir@
     305ac_ct_AR = @ac_ct_AR@
    275306ac_ct_CC = @ac_ct_CC@
    276307ac_ct_CXX = @ac_ct_CXX@
     308ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
    277309am__include = @am__include@
    278310am__leading_dot = @am__leading_dot@
     
    281313am__untar = @am__untar@
    282314bindir = @bindir@
     315build = @build@
    283316build_alias = @build_alias@
     317build_cpu = @build_cpu@
     318build_os = @build_os@
     319build_vendor = @build_vendor@
    284320builddir = @builddir@
    285321datadir = @datadir@
     
    288324dvidir = @dvidir@
    289325exec_prefix = @exec_prefix@
     326host = @host@
    290327host_alias = @host_alias@
     328host_cpu = @host_cpu@
     329host_os = @host_os@
     330host_vendor = @host_vendor@
    291331htmldir = @htmldir@
    292332includedir = @includedir@
     
    314354top_srcdir = @top_srcdir@
    315355AUTOMAKE_OPTIONS = foreign # do not require all the GNU file names
     356ACLOCAL_AMFLAGS = -I automake
    316357SUBDIRS = prelude src      # order important
    317358all: all-recursive
     
    351392        $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
    352393$(am__aclocal_m4_deps):
     394
     395mostlyclean-libtool:
     396        -rm -f *.lo
     397
     398clean-libtool:
     399        -rm -rf .libs _libs
     400
     401distclean-libtool:
     402        -rm -f libtool config.lt
    353403
    354404# This directory's subdirectories are mostly independent; you can cd
     
    683733clean: clean-recursive
    684734
    685 clean-am: clean-generic mostlyclean-am
     735clean-am: clean-generic clean-libtool mostlyclean-am
    686736
    687737distclean: distclean-recursive
    688738        -rm -f $(am__CONFIG_DISTCLEAN_FILES)
    689739        -rm -f Makefile
    690 distclean-am: clean-am distclean-generic distclean-tags
     740distclean-am: clean-am distclean-generic distclean-libtool \
     741        distclean-tags
    691742
    692743dvi: dvi-recursive
     
    738789mostlyclean: mostlyclean-recursive
    739790
    740 mostlyclean-am: mostlyclean-generic
     791mostlyclean-am: mostlyclean-generic mostlyclean-libtool
    741792
    742793pdf: pdf-recursive
     
    754805.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
    755806        am--refresh check check-am clean clean-cscope clean-generic \
    756         cscope cscopelist-am ctags ctags-am dist dist-all dist-bzip2 \
    757         dist-gzip dist-lzip dist-shar dist-tarZ dist-xz dist-zip \
    758         distcheck distclean distclean-generic distclean-tags \
    759         distcleancheck distdir distuninstallcheck dvi dvi-am html \
    760         html-am info info-am install install-am install-data \
    761         install-data-am install-dvi install-dvi-am install-exec \
    762         install-exec-am install-html install-html-am install-info \
    763         install-info-am install-man install-pdf install-pdf-am \
    764         install-ps install-ps-am install-strip installcheck \
    765         installcheck-am installdirs installdirs-am maintainer-clean \
    766         maintainer-clean-generic mostlyclean mostlyclean-generic pdf \
    767         pdf-am ps ps-am tags tags-am uninstall uninstall-am
     807        clean-libtool cscope cscopelist-am ctags ctags-am dist \
     808        dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \
     809        dist-xz dist-zip distcheck distclean distclean-generic \
     810        distclean-libtool distclean-tags distcleancheck distdir \
     811        distuninstallcheck dvi dvi-am html html-am info info-am \
     812        install install-am install-data install-data-am install-dvi \
     813        install-dvi-am install-exec install-exec-am install-html \
     814        install-html-am install-info install-info-am install-man \
     815        install-pdf install-pdf-am install-ps install-ps-am \
     816        install-strip installcheck installcheck-am installdirs \
     817        installdirs-am maintainer-clean maintainer-clean-generic \
     818        mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
     819        ps ps-am tags tags-am uninstall uninstall-am
    768820
    769821.PRECIOUS: Makefile
  • libcfa/aclocal.m4

    r7b61ce8 r1f690b3  
    11711171]) # _AM_PROG_TAR
    11721172
     1173m4_include([automake/libtool.m4])
     1174m4_include([automake/ltoptions.m4])
     1175m4_include([automake/ltsugar.m4])
     1176m4_include([automake/ltversion.m4])
     1177m4_include([automake/lt~obsolete.m4])
  • libcfa/configure

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