Changes in / [560812b:2725882]


Ignore:
Files:
9 added
18 edited

Legend:

Unmodified
Added
Removed
  • benchmark/Makefile.in

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

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

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

    r560812b r2725882  
    405405
    406406                // include the cfa library in case it's needed
    407                 args[nargs] = ( *new string( string("-L" ) + libdir + (intree ? "/src" : "")) ).c_str();
     407                args[nargs] = ( *new string( string("-L" ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
     408                nargs += 1;
     409                args[nargs] = ( *new string( string("-Wl,-rpath," ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
    408410                nargs += 1;
    409411                args[nargs] = "-lcfa";
  • libcfa/Makefile.am

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

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

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

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