Changeset 4ecf14f in mod_gnutls for configure


Ignore:
Timestamp:
Jan 11, 2013, 12:57:28 AM (7 years ago)
Author:
Daniel Kahn Gillmor <dkg@…>
Branches:
debian/master, debian/stretch-backports, jessie-backports, upstream
Children:
241fee8, 52b649e
Parents:
f8ffc43
Message:

Imported Upstream version 0.5.4

File:
1 edited

Legend:

Unmodified
Added
Removed
  • configure

    rf8ffc43 r4ecf14f  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.61 for mod_gnutls 0.5.3.
     3# Generated by GNU Autoconf 2.61 for mod_gnutls 0.5.4.
    44#
    55# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
     
    554554SHELL=${CONFIG_SHELL-/bin/sh}
    555555
    556 case X$ECHO in
     556case X$lt_ECHO in
    557557X*--fallback-echo)
    558558  # Remove one level of quotation (which was required for Make).
    559   ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','`
     559  ECHO=`echo "$lt_ECHO" | sed 's,\\\\\$\\$0,'$0','`
    560560  ;;
    561561esac
    562562
    563 echo=${ECHO-echo}
     563ECHO=${lt_ECHO-echo}
    564564if test "X$1" = X--no-reexec; then
    565565  # Discard the --no-reexec flag, and continue.
     
    568568  # Avoid inline document here, it may be left over
    569569  :
    570 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
    571   # Yippee, $echo works!
     570elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' ; then
     571  # Yippee, $ECHO works!
    572572  :
    573573else
     
    579579  # used as fallback echo
    580580  shift
    581   cat <<EOF
     581  cat <<_LT_EOF
    582582$*
    583 EOF
     583_LT_EOF
    584584  exit 0
    585585fi
     
    589589(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
    590590
    591 if test -z "$ECHO"; then
    592 if test "X${echo_test_string+set}" != Xset; then
    593 # find a string as large as possible, as long as the shell can cope with it
    594   for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do
    595     # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
    596     if (echo_test_string=`eval $cmd`) 2>/dev/null &&
    597        echo_test_string=`eval $cmd` &&
    598        (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
    599     then
    600       break
    601     fi
    602   done
    603 fi
    604 
    605 if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
    606    echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
    607    test "X$echo_testing_string" = "X$echo_test_string"; then
    608   :
    609 else
    610   # The Solaris, AIX, and Digital Unix default echo programs unquote
    611   # backslashes.  This makes it impossible to quote backslashes using
    612   #   echo "$something" | sed 's/\\/\\\\/g'
    613   #
    614   # So, first we look for a working echo in the user's PATH.
    615 
    616   lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
    617   for dir in $PATH /usr/ucb; do
     591if test -z "$lt_ECHO"; then
     592  if test "X${echo_test_string+set}" != Xset; then
     593    # find a string as large as possible, as long as the shell can cope with it
     594    for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do
     595      # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
     596      if { echo_test_string=`eval $cmd`; } 2>/dev/null &&
     597         { test "X$echo_test_string" = "X$echo_test_string"; } 2>/dev/null
     598      then
     599        break
     600      fi
     601    done
     602  fi
     603
     604  if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
     605     echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
     606     test "X$echo_testing_string" = "X$echo_test_string"; then
     607    :
     608  else
     609    # The Solaris, AIX, and Digital Unix default echo programs unquote
     610    # backslashes.  This makes it impossible to quote backslashes using
     611    #   echo "$something" | sed 's/\\/\\\\/g'
     612    #
     613    # So, first we look for a working echo in the user's PATH.
     614
     615    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     616    for dir in $PATH /usr/ucb; do
     617      IFS="$lt_save_ifs"
     618      if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
     619         test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
     620         echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
     621         test "X$echo_testing_string" = "X$echo_test_string"; then
     622        ECHO="$dir/echo"
     623        break
     624      fi
     625    done
    618626    IFS="$lt_save_ifs"
    619     if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
    620        test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
    621        echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
    622        test "X$echo_testing_string" = "X$echo_test_string"; then
    623       echo="$dir/echo"
    624       break
    625     fi
    626   done
    627   IFS="$lt_save_ifs"
    628 
    629   if test "X$echo" = Xecho; then
    630     # We didn't find a better echo, so look for alternatives.
    631     if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
    632        echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
    633        test "X$echo_testing_string" = "X$echo_test_string"; then
    634       # This shell has a builtin print -r that does the trick.
    635       echo='print -r'
    636     elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
    637          test "X$CONFIG_SHELL" != X/bin/ksh; then
    638       # If we have ksh, try running configure again with it.
    639       ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
    640       export ORIGINAL_CONFIG_SHELL
    641       CONFIG_SHELL=/bin/ksh
    642       export CONFIG_SHELL
    643       exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"}
    644     else
    645       # Try using printf.
    646       echo='printf %s\n'
    647       if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
    648          echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
    649          test "X$echo_testing_string" = "X$echo_test_string"; then
    650         # Cool, printf works
    651         :
    652       elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
    653            test "X$echo_testing_string" = 'X\t' &&
    654            echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
     627
     628    if test "X$ECHO" = Xecho; then
     629      # We didn't find a better echo, so look for alternatives.
     630      if test "X`{ print -r '\t'; } 2>/dev/null`" = 'X\t' &&
     631         echo_testing_string=`{ print -r "$echo_test_string"; } 2>/dev/null` &&
     632         test "X$echo_testing_string" = "X$echo_test_string"; then
     633        # This shell has a builtin print -r that does the trick.
     634        ECHO='print -r'
     635      elif { test -f /bin/ksh || test -f /bin/ksh$ac_exeext; } &&
     636           test "X$CONFIG_SHELL" != X/bin/ksh; then
     637        # If we have ksh, try running configure again with it.
     638        ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
     639        export ORIGINAL_CONFIG_SHELL
     640        CONFIG_SHELL=/bin/ksh
     641        export CONFIG_SHELL
     642        exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"}
     643      else
     644        # Try using printf.
     645        ECHO='printf %s\n'
     646        if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
     647           echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
    655648           test "X$echo_testing_string" = "X$echo_test_string"; then
    656         CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
    657         export CONFIG_SHELL
    658         SHELL="$CONFIG_SHELL"
    659         export SHELL
    660         echo="$CONFIG_SHELL $0 --fallback-echo"
    661       elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
    662            test "X$echo_testing_string" = 'X\t' &&
    663            echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
    664            test "X$echo_testing_string" = "X$echo_test_string"; then
    665         echo="$CONFIG_SHELL $0 --fallback-echo"
    666       else
    667         # maybe with a smaller string...
    668         prev=:
    669 
    670         for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do
    671           if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
    672           then
    673             break
     649          # Cool, printf works
     650          :
     651        elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
     652             test "X$echo_testing_string" = 'X\t' &&
     653             echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
     654             test "X$echo_testing_string" = "X$echo_test_string"; then
     655          CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
     656          export CONFIG_SHELL
     657          SHELL="$CONFIG_SHELL"
     658          export SHELL
     659          ECHO="$CONFIG_SHELL $0 --fallback-echo"
     660        elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
     661             test "X$echo_testing_string" = 'X\t' &&
     662             echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
     663             test "X$echo_testing_string" = "X$echo_test_string"; then
     664          ECHO="$CONFIG_SHELL $0 --fallback-echo"
     665        else
     666          # maybe with a smaller string...
     667          prev=:
     668
     669          for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do
     670            if { test "X$echo_test_string" = "X`eval $cmd`"; } 2>/dev/null
     671            then
     672              break
     673            fi
     674            prev="$cmd"
     675          done
     676
     677          if test "$prev" != 'sed 50q "$0"'; then
     678            echo_test_string=`eval $prev`
     679            export echo_test_string
     680            exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"}
     681          else
     682            # Oops.  We lost completely, so just stick with echo.
     683            ECHO=echo
    674684          fi
    675           prev="$cmd"
    676         done
    677 
    678         if test "$prev" != 'sed 50q "$0"'; then
    679           echo_test_string=`eval $prev`
    680           export echo_test_string
    681           exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"}
    682         else
    683           # Oops.  We lost completely, so just stick with echo.
    684           echo=echo
    685         fi
     685        fi
    686686      fi
    687687    fi
    688688  fi
    689689fi
    690 fi
    691690
    692691# Copy echo and quote the copy suitably for passing to libtool from
    693692# the Makefile, instead of quoting the original, which is used later.
    694 ECHO=$echo
    695 if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then
    696    ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"
    697 fi
    698 
    699 
    700 
    701 
    702 tagnames=${tagnames+${tagnames},}CXX
    703 
    704 tagnames=${tagnames+${tagnames},}F77
     693lt_ECHO=$ECHO
     694if test "X$lt_ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then
     695   lt_ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"
     696fi
     697
     698
     699
    705700
    706701exec 7<&0 </dev/null 6>&1
     
    727722PACKAGE_NAME='mod_gnutls'
    728723PACKAGE_TARNAME='mod_gnutls'
    729 PACKAGE_VERSION='0.5.3'
    730 PACKAGE_STRING='mod_gnutls 0.5.3'
     724PACKAGE_VERSION='0.5.4'
     725PACKAGE_STRING='mod_gnutls 0.5.4'
    731726PACKAGE_BUGREPORT=''
    732727
     
    863858GREP
    864859EGREP
     860FGREP
     861LD
     862LIBTOOL
     863DUMPBIN
     864ac_ct_DUMPBIN
     865NM
    865866LN_S
    866 ECHO
    867867AR
    868868RANLIB
     869lt_ECHO
    869870DSYMUTIL
    870871NMEDIT
     872LIPO
     873OTOOL
     874OTOOL64
    871875CPP
    872 CXX
    873 CXXFLAGS
    874 ac_ct_CXX
    875 CXXDEPMODE
    876 am__fastdepCXX_TRUE
    877 am__fastdepCXX_FALSE
    878 CXXCPP
    879 F77
    880 FFLAGS
    881 ac_ct_F77
    882 LIBTOOL
    883876APXS_BIN
    884877AP_DEFS
     
    905898APXS_EXTENSION
    906899APXS_CFLAGS
    907 LIBGNUTLS_CONFIG
     900PKG_CONFIG
     901GNUTLS_CERTTOOL
    908902LIBGNUTLS_CFLAGS
    909903LIBGNUTLS_LIBS
     
    927921LIBS
    928922CPPFLAGS
    929 CPP
    930 CXX
    931 CXXFLAGS
    932 CCC
    933 CXXCPP
    934 F77
    935 FFLAGS'
     923CPP'
    936924
    937925
     
    14361424  # This message is too long to be a string in the A/UX 3.1 sh.
    14371425  cat <<_ACEOF
    1438 \`configure' configures mod_gnutls 0.5.3 to adapt to many kinds of systems.
     1426\`configure' configures mod_gnutls 0.5.4 to adapt to many kinds of systems.
    14391427
    14401428Usage: $0 [OPTION]... [VAR=VALUE]...
     
    15071495if test -n "$ac_init_help"; then
    15081496  case $ac_init_help in
    1509      short | recursive ) echo "Configuration of mod_gnutls 0.5.3:";;
     1497     short | recursive ) echo "Configuration of mod_gnutls 0.5.4:";;
    15101498   esac
    15111499  cat <<\_ACEOF
     
    15341522  --with-pic              try to use only PIC/non-PIC objects [default=use
    15351523                          both]
    1536   --with-tags[=TAGS]      include additional configurations [automatic]
    15371524  --with-apxs=PATH        Path to apxs
    15381525  --with-libgnutls-prefix=PFX   Prefix where libgnutls is installed (optional)
     
    15531540              you have headers in a nonstandard directory <include dir>
    15541541  CPP         C preprocessor
    1555   CXX         C++ compiler command
    1556   CXXFLAGS    C++ compiler flags
    1557   CXXCPP      C++ preprocessor
    1558   F77         Fortran 77 compiler command
    1559   FFLAGS      Fortran 77 compiler flags
    15601542
    15611543Use these variables to override the choices made by `configure' or to help
     
    16221604if $ac_init_version; then
    16231605  cat <<\_ACEOF
    1624 mod_gnutls configure 0.5.3
     1606mod_gnutls configure 0.5.4
    16251607generated by GNU Autoconf 2.61
    16261608
     
    16361618running configure, to aid debugging if configure makes a mistake.
    16371619
    1638 It was created by mod_gnutls $as_me 0.5.3, which was
     1620It was created by mod_gnutls $as_me 0.5.4, which was
    16391621generated by GNU Autoconf 2.61.  Invocation command line was
    16401622
     
    20071989  chmod +x config.nice
    20081990
    2009 MOD_GNUTLS_VERSION=0.5.3
     1991MOD_GNUTLS_VERSION=0.5.4
    20101992
    20111993
     
    25082490# Define the identity of the package.
    25092491 PACKAGE=mod_gnutls
    2510  VERSION=0.5.3
     2492 VERSION=0.5.4
    25112493
    25122494
     
    37503732{ echo "$as_me:$LINENO: checking for a sed that does not truncate output" >&5
    37513733echo $ECHO_N "checking for a sed that does not truncate output... $ECHO_C" >&6; }
    3752 if test "${lt_cv_path_SED+set}" = set; then
     3734if test "${ac_cv_path_SED+set}" = set; then
    37533735  echo $ECHO_N "(cached) $ECHO_C" >&6
    37543736else
    3755   # Loop through the user's path and test for sed and gsed.
    3756 # Then use that list of sed's as ones to test for truncation.
     3737            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
     3738     for ac_i in 1 2 3 4 5 6 7; do
     3739       ac_script="$ac_script$as_nl$ac_script"
     3740     done
     3741     echo "$ac_script" | sed 99q >conftest.sed
     3742     $as_unset ac_script || ac_script=
     3743     # Extract the first word of "sed gsed" to use in msg output
     3744if test -z "$SED"; then
     3745set dummy sed gsed; ac_prog_name=$2
     3746if test "${ac_cv_path_SED+set}" = set; then
     3747  echo $ECHO_N "(cached) $ECHO_C" >&6
     3748else
     3749  ac_path_SED_found=false
     3750# Loop through the user's path and test for each of PROGNAME-LIST
    37573751as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    37583752for as_dir in $PATH
     
    37603754  IFS=$as_save_IFS
    37613755  test -z "$as_dir" && as_dir=.
    3762   for lt_ac_prog in sed gsed; do
    3763     for ac_exec_ext in '' $ac_executable_extensions; do
    3764       if { test -f "$as_dir/$lt_ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$lt_ac_prog$ac_exec_ext"; }; then
    3765         lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
    3766       fi
    3767     done
     3756  for ac_prog in sed gsed; do
     3757  for ac_exec_ext in '' $ac_executable_extensions; do
     3758    ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
     3759    { test -f "$ac_path_SED" && $as_test_x "$ac_path_SED"; } || continue
     3760    # Check for GNU ac_path_SED and select it if it is found.
     3761  # Check for GNU $ac_path_SED
     3762case `"$ac_path_SED" --version 2>&1` in
     3763*GNU*)
     3764  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
     3765*)
     3766  ac_count=0
     3767  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
     3768  while :
     3769  do
     3770    cat "conftest.in" "conftest.in" >"conftest.tmp"
     3771    mv "conftest.tmp" "conftest.in"
     3772    cp "conftest.in" "conftest.nl"
     3773    echo '' >> "conftest.nl"
     3774    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
     3775    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
     3776    ac_count=`expr $ac_count + 1`
     3777    if test $ac_count -gt ${ac_path_SED_max-0}; then
     3778      # Best one so far, save it but keep looking for a better one
     3779      ac_cv_path_SED="$ac_path_SED"
     3780      ac_path_SED_max=$ac_count
     3781    fi
     3782    # 10*(2^10) chars as input seems more than enough
     3783    test $ac_count -gt 10 && break
     3784  done
     3785  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
     3786esac
     3787
     3788
     3789    $ac_path_SED_found && break 3
    37683790  done
    37693791done
     3792
     3793done
    37703794IFS=$as_save_IFS
    3771 lt_ac_max=0
    3772 lt_ac_count=0
    3773 # Add /usr/xpg4/bin/sed as it is typically found on Solaris
    3774 # along with /bin/sed that truncates output.
    3775 for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
    3776   test ! -f $lt_ac_sed && continue
    3777   cat /dev/null > conftest.in
    3778   lt_ac_count=0
    3779   echo $ECHO_N "0123456789$ECHO_C" >conftest.in
    3780   # Check for GNU sed and select it if it is found.
    3781   if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
    3782     lt_cv_path_SED=$lt_ac_sed
    3783     break
    3784   fi
    3785   while true; do
    3786     cat conftest.in conftest.in >conftest.tmp
    3787     mv conftest.tmp conftest.in
    3788     cp conftest.in conftest.nl
    3789     echo >>conftest.nl
    3790     $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
    3791     cmp -s conftest.out conftest.nl || break
    3792     # 10000 chars as input seems more than enough
    3793     test $lt_ac_count -gt 10 && break
    3794     lt_ac_count=`expr $lt_ac_count + 1`
    3795     if test $lt_ac_count -gt $lt_ac_max; then
    3796       lt_ac_max=$lt_ac_count
    3797       lt_cv_path_SED=$lt_ac_sed
    3798     fi
    3799   done
    3800 done
    3801 
    3802 fi
    3803 
    3804 SED=$lt_cv_path_SED
    3805 
    3806 { echo "$as_me:$LINENO: result: $SED" >&5
    3807 echo "${ECHO_T}$SED" >&6; }
     3795
     3796
     3797fi
     3798
     3799SED="$ac_cv_path_SED"
     3800if test -z "$SED"; then
     3801  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in \$PATH" >&5
     3802echo "$as_me: error: no acceptable $ac_prog_name could be found in \$PATH" >&2;}
     3803   { (exit 1); exit 1; }; }
     3804fi
     3805
     3806else
     3807  ac_cv_path_SED=$SED
     3808fi
     3809
     3810fi
     3811{ echo "$as_me:$LINENO: result: $ac_cv_path_SED" >&5
     3812echo "${ECHO_T}$ac_cv_path_SED" >&6; }
     3813 SED="$ac_cv_path_SED"
     3814  rm -f conftest.sed
     3815
     3816test -z "$SED" && SED=sed
     3817Xsed="$SED -e 1s/^X//"
     3818
     3819
     3820
     3821
     3822
     3823
     3824
     3825
     3826
     3827
    38083828
    38093829{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
     
    39693989
    39703990
     3991{ echo "$as_me:$LINENO: checking for fgrep" >&5
     3992echo $ECHO_N "checking for fgrep... $ECHO_C" >&6; }
     3993if test "${ac_cv_path_FGREP+set}" = set; then
     3994  echo $ECHO_N "(cached) $ECHO_C" >&6
     3995else
     3996  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
     3997   then ac_cv_path_FGREP="$GREP -F"
     3998   else
     3999     # Extract the first word of "fgrep" to use in msg output
     4000if test -z "$FGREP"; then
     4001set dummy fgrep; ac_prog_name=$2
     4002if test "${ac_cv_path_FGREP+set}" = set; then
     4003  echo $ECHO_N "(cached) $ECHO_C" >&6
     4004else
     4005  ac_path_FGREP_found=false
     4006# Loop through the user's path and test for each of PROGNAME-LIST
     4007as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4008for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
     4009do
     4010  IFS=$as_save_IFS
     4011  test -z "$as_dir" && as_dir=.
     4012  for ac_prog in fgrep; do
     4013  for ac_exec_ext in '' $ac_executable_extensions; do
     4014    ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
     4015    { test -f "$ac_path_FGREP" && $as_test_x "$ac_path_FGREP"; } || continue
     4016    # Check for GNU ac_path_FGREP and select it if it is found.
     4017  # Check for GNU $ac_path_FGREP
     4018case `"$ac_path_FGREP" --version 2>&1` in
     4019*GNU*)
     4020  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
     4021*)
     4022  ac_count=0
     4023  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
     4024  while :
     4025  do
     4026    cat "conftest.in" "conftest.in" >"conftest.tmp"
     4027    mv "conftest.tmp" "conftest.in"
     4028    cp "conftest.in" "conftest.nl"
     4029    echo 'FGREP' >> "conftest.nl"
     4030    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
     4031    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
     4032    ac_count=`expr $ac_count + 1`
     4033    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
     4034      # Best one so far, save it but keep looking for a better one
     4035      ac_cv_path_FGREP="$ac_path_FGREP"
     4036      ac_path_FGREP_max=$ac_count
     4037    fi
     4038    # 10*(2^10) chars as input seems more than enough
     4039    test $ac_count -gt 10 && break
     4040  done
     4041  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
     4042esac
     4043
     4044
     4045    $ac_path_FGREP_found && break 3
     4046  done
     4047done
     4048
     4049done
     4050IFS=$as_save_IFS
     4051
     4052
     4053fi
     4054
     4055FGREP="$ac_cv_path_FGREP"
     4056if test -z "$FGREP"; then
     4057  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
     4058echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
     4059   { (exit 1); exit 1; }; }
     4060fi
     4061
     4062else
     4063  ac_cv_path_FGREP=$FGREP
     4064fi
     4065
     4066
     4067   fi
     4068fi
     4069{ echo "$as_me:$LINENO: result: $ac_cv_path_FGREP" >&5
     4070echo "${ECHO_T}$ac_cv_path_FGREP" >&6; }
     4071 FGREP="$ac_cv_path_FGREP"
     4072
     4073
     4074test -z "$GREP" && GREP=grep
     4075
     4076
     4077
     4078
     4079
     4080
     4081
     4082
     4083
     4084
     4085
     4086
     4087
     4088
     4089
     4090
     4091
     4092
    39714093
    39724094# Check whether --with-gnu-ld was given.
     
    39944116      re_direlt='/[^/][^/]*/\.\./'
    39954117      # Canonicalize the pathname of ld
    3996       ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
    3997       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
    3998         ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
     4118      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
     4119      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
     4120        ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
    39994121      done
    40004122      test -z "$LD" && LD="$ac_prog"
     
    40744196echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6; }
    40754197with_gnu_ld=$lt_cv_prog_gnu_ld
     4198
     4199
     4200
     4201
     4202
     4203
     4204
    40764205
    40774206
     
    41564285test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
    41574286
    4158 # Check whether --enable-shared was given.
    4159 if test "${enable_shared+set}" = set; then
    4160   enableval=$enable_shared; p=${PACKAGE-default}
    4161     case $enableval in
    4162     yes) enable_shared=yes ;;
    4163     no) enable_shared=no ;;
    4164     *)
    4165       enable_shared=no
    4166       # Look at the argument we got.  We use all the common list separators.
    4167       lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
    4168       for pkg in $enableval; do
    4169         IFS="$lt_save_ifs"
    4170         if test "X$pkg" = "X$p"; then
    4171           enable_shared=yes
    4172         fi
    4173       done
    4174       IFS="$lt_save_ifs"
    4175       ;;
    4176     esac
    4177 else
    4178   enable_shared=yes
    4179 fi
    4180 
    4181 
    4182 # Check whether --enable-static was given.
    4183 if test "${enable_static+set}" = set; then
    4184   enableval=$enable_static; p=${PACKAGE-default}
    4185     case $enableval in
    4186     yes) enable_static=yes ;;
    4187     no) enable_static=no ;;
    4188     *)
    4189      enable_static=no
    4190       # Look at the argument we got.  We use all the common list separators.
    4191       lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
    4192       for pkg in $enableval; do
    4193         IFS="$lt_save_ifs"
    4194         if test "X$pkg" = "X$p"; then
    4195           enable_static=yes
    4196         fi
    4197       done
    4198       IFS="$lt_save_ifs"
    4199       ;;
    4200     esac
    4201 else
    4202   enable_static=yes
    4203 fi
    4204 
    4205 
    4206 # Check whether --enable-fast-install was given.
    4207 if test "${enable_fast_install+set}" = set; then
    4208   enableval=$enable_fast_install; p=${PACKAGE-default}
    4209     case $enableval in
    4210     yes) enable_fast_install=yes ;;
    4211     no) enable_fast_install=no ;;
    4212     *)
    4213       enable_fast_install=no
    4214       # Look at the argument we got.  We use all the common list separators.
    4215       lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
    4216       for pkg in $enableval; do
    4217         IFS="$lt_save_ifs"
    4218         if test "X$pkg" = "X$p"; then
    4219           enable_fast_install=yes
    4220         fi
    4221       done
    4222       IFS="$lt_save_ifs"
    4223       ;;
    4224     esac
    4225 else
    4226   enable_fast_install=yes
    4227 fi
    4228 
    4229 
    4230 { echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
    4231 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
    4232 if test "${lt_cv_ld_reload_flag+set}" = set; then
    4233   echo $ECHO_N "(cached) $ECHO_C" >&6
    4234 else
    4235   lt_cv_ld_reload_flag='-r'
    4236 fi
    4237 { echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
    4238 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
    4239 reload_flag=$lt_cv_ld_reload_flag
    4240 case $reload_flag in
    4241 "" | " "*) ;;
    4242 *) reload_flag=" $reload_flag" ;;
     4287case `pwd` in
     4288  *\ * | *\     *)
     4289    { echo "$as_me:$LINENO: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
     4290echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
    42434291esac
    4244 reload_cmds='$LD$reload_flag -o $output$reload_objs'
    4245 case $host_os in
    4246   darwin*)
    4247     if test "$GCC" = yes; then
    4248       reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
    4249     else
    4250       reload_cmds='$LD$reload_flag -o $output$reload_objs'
    4251     fi
    4252     ;;
    4253 esac
    4254 
    4255 { echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
    4256 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6; }
     4292
     4293
     4294
     4295macro_version='2.2.4'
     4296macro_revision='1.2976'
     4297
     4298
     4299
     4300
     4301
     4302
     4303
     4304
     4305
     4306
     4307
     4308
     4309
     4310ltmain="$ac_aux_dir/ltmain.sh"
     4311
     4312{ echo "$as_me:$LINENO: checking for BSD- or MS-compatible name lister (nm)" >&5
     4313echo $ECHO_N "checking for BSD- or MS-compatible name lister (nm)... $ECHO_C" >&6; }
    42574314if test "${lt_cv_path_NM+set}" = set; then
    42584315  echo $ECHO_N "(cached) $ECHO_C" >&6
     
    42994356    IFS="$lt_save_ifs"
    43004357  done
    4301   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
     4358  : ${lt_cv_path_NM=no}
    43024359fi
    43034360fi
    43044361{ echo "$as_me:$LINENO: result: $lt_cv_path_NM" >&5
    43054362echo "${ECHO_T}$lt_cv_path_NM" >&6; }
    4306 NM="$lt_cv_path_NM"
     4363if test "$lt_cv_path_NM" != "no"; then
     4364  NM="$lt_cv_path_NM"
     4365else
     4366  # Didn't find any BSD compatible name lister, look for dumpbin.
     4367  if test -n "$ac_tool_prefix"; then
     4368  for ac_prog in "dumpbin -symbols" "link -dump -symbols"
     4369  do
     4370    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     4371set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     4372{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     4373echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     4374if test "${ac_cv_prog_DUMPBIN+set}" = set; then
     4375  echo $ECHO_N "(cached) $ECHO_C" >&6
     4376else
     4377  if test -n "$DUMPBIN"; then
     4378  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
     4379else
     4380as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4381for as_dir in $PATH
     4382do
     4383  IFS=$as_save_IFS
     4384  test -z "$as_dir" && as_dir=.
     4385  for ac_exec_ext in '' $ac_executable_extensions; do
     4386  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4387    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
     4388    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     4389    break 2
     4390  fi
     4391done
     4392done
     4393IFS=$as_save_IFS
     4394
     4395fi
     4396fi
     4397DUMPBIN=$ac_cv_prog_DUMPBIN
     4398if test -n "$DUMPBIN"; then
     4399  { echo "$as_me:$LINENO: result: $DUMPBIN" >&5
     4400echo "${ECHO_T}$DUMPBIN" >&6; }
     4401else
     4402  { echo "$as_me:$LINENO: result: no" >&5
     4403echo "${ECHO_T}no" >&6; }
     4404fi
     4405
     4406
     4407    test -n "$DUMPBIN" && break
     4408  done
     4409fi
     4410if test -z "$DUMPBIN"; then
     4411  ac_ct_DUMPBIN=$DUMPBIN
     4412  for ac_prog in "dumpbin -symbols" "link -dump -symbols"
     4413do
     4414  # Extract the first word of "$ac_prog", so it can be a program name with args.
     4415set dummy $ac_prog; ac_word=$2
     4416{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     4417echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     4418if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then
     4419  echo $ECHO_N "(cached) $ECHO_C" >&6
     4420else
     4421  if test -n "$ac_ct_DUMPBIN"; then
     4422  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
     4423else
     4424as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4425for as_dir in $PATH
     4426do
     4427  IFS=$as_save_IFS
     4428  test -z "$as_dir" && as_dir=.
     4429  for ac_exec_ext in '' $ac_executable_extensions; do
     4430  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4431    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
     4432    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     4433    break 2
     4434  fi
     4435done
     4436done
     4437IFS=$as_save_IFS
     4438
     4439fi
     4440fi
     4441ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
     4442if test -n "$ac_ct_DUMPBIN"; then
     4443  { echo "$as_me:$LINENO: result: $ac_ct_DUMPBIN" >&5
     4444echo "${ECHO_T}$ac_ct_DUMPBIN" >&6; }
     4445else
     4446  { echo "$as_me:$LINENO: result: no" >&5
     4447echo "${ECHO_T}no" >&6; }
     4448fi
     4449
     4450
     4451  test -n "$ac_ct_DUMPBIN" && break
     4452done
     4453
     4454  if test "x$ac_ct_DUMPBIN" = x; then
     4455    DUMPBIN=":"
     4456  else
     4457    case $cross_compiling:$ac_tool_warned in
     4458yes:)
     4459{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     4460whose name does not start with the host triplet.  If you think this
     4461configuration is useful to you, please write to autoconf@gnu.org." >&5
     4462echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     4463whose name does not start with the host triplet.  If you think this
     4464configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     4465ac_tool_warned=yes ;;
     4466esac
     4467    DUMPBIN=$ac_ct_DUMPBIN
     4468  fi
     4469fi
     4470
     4471
     4472  if test "$DUMPBIN" != ":"; then
     4473    NM="$DUMPBIN"
     4474  fi
     4475fi
     4476test -z "$NM" && NM=nm
     4477
     4478
     4479
     4480
     4481
     4482
     4483{ echo "$as_me:$LINENO: checking the name lister ($NM) interface" >&5
     4484echo $ECHO_N "checking the name lister ($NM) interface... $ECHO_C" >&6; }
     4485if test "${lt_cv_nm_interface+set}" = set; then
     4486  echo $ECHO_N "(cached) $ECHO_C" >&6
     4487else
     4488  lt_cv_nm_interface="BSD nm"
     4489  echo "int some_variable = 0;" > conftest.$ac_ext
     4490  (eval echo "\"\$as_me:4490: $ac_compile\"" >&5)
     4491  (eval "$ac_compile" 2>conftest.err)
     4492  cat conftest.err >&5
     4493  (eval echo "\"\$as_me:4493: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
     4494  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
     4495  cat conftest.err >&5
     4496  (eval echo "\"\$as_me:4496: output\"" >&5)
     4497  cat conftest.out >&5
     4498  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
     4499    lt_cv_nm_interface="MS dumpbin"
     4500  fi
     4501  rm -f conftest*
     4502fi
     4503{ echo "$as_me:$LINENO: result: $lt_cv_nm_interface" >&5
     4504echo "${ECHO_T}$lt_cv_nm_interface" >&6; }
    43074505
    43084506{ echo "$as_me:$LINENO: checking whether ln -s works" >&5
     
    43164514echo "${ECHO_T}no, using $LN_S" >&6; }
    43174515fi
     4516
     4517# find the maximum length of command line arguments
     4518{ echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
     4519echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
     4520if test "${lt_cv_sys_max_cmd_len+set}" = set; then
     4521  echo $ECHO_N "(cached) $ECHO_C" >&6
     4522else
     4523    i=0
     4524  teststring="ABCD"
     4525
     4526  case $build_os in
     4527  msdosdjgpp*)
     4528    # On DJGPP, this test can blow up pretty badly due to problems in libc
     4529    # (any single argument exceeding 2000 bytes causes a buffer overrun
     4530    # during glob expansion).  Even if it were fixed, the result of this
     4531    # check would be larger than it should be.
     4532    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
     4533    ;;
     4534
     4535  gnu*)
     4536    # Under GNU Hurd, this test is not required because there is
     4537    # no limit to the length of command line arguments.
     4538    # Libtool will interpret -1 as no limit whatsoever
     4539    lt_cv_sys_max_cmd_len=-1;
     4540    ;;
     4541
     4542  cygwin* | mingw*)
     4543    # On Win9x/ME, this test blows up -- it succeeds, but takes
     4544    # about 5 minutes as the teststring grows exponentially.
     4545    # Worse, since 9x/ME are not pre-emptively multitasking,
     4546    # you end up with a "frozen" computer, even though with patience
     4547    # the test eventually succeeds (with a max line length of 256k).
     4548    # Instead, let's just punt: use the minimum linelength reported by
     4549    # all of the supported platforms: 8192 (on NT/2K/XP).
     4550    lt_cv_sys_max_cmd_len=8192;
     4551    ;;
     4552
     4553  amigaos*)
     4554    # On AmigaOS with pdksh, this test takes hours, literally.
     4555    # So we just punt and use a minimum line length of 8192.
     4556    lt_cv_sys_max_cmd_len=8192;
     4557    ;;
     4558
     4559  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
     4560    # This has been around since 386BSD, at least.  Likely further.
     4561    if test -x /sbin/sysctl; then
     4562      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
     4563    elif test -x /usr/sbin/sysctl; then
     4564      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
     4565    else
     4566      lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
     4567    fi
     4568    # And add a safety zone
     4569    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
     4570    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
     4571    ;;
     4572
     4573  interix*)
     4574    # We know the value 262144 and hardcode it with a safety zone (like BSD)
     4575    lt_cv_sys_max_cmd_len=196608
     4576    ;;
     4577
     4578  osf*)
     4579    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
     4580    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
     4581    # nice to cause kernel panics so lets avoid the loop below.
     4582    # First set a reasonable default.
     4583    lt_cv_sys_max_cmd_len=16384
     4584    #
     4585    if test -x /sbin/sysconfig; then
     4586      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
     4587        *1*) lt_cv_sys_max_cmd_len=-1 ;;
     4588      esac
     4589    fi
     4590    ;;
     4591  sco3.2v5*)
     4592    lt_cv_sys_max_cmd_len=102400
     4593    ;;
     4594  sysv5* | sco5v6* | sysv4.2uw2*)
     4595    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
     4596    if test -n "$kargmax"; then
     4597      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[  ]//'`
     4598    else
     4599      lt_cv_sys_max_cmd_len=32768
     4600    fi
     4601    ;;
     4602  *)
     4603    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
     4604    if test -n "$lt_cv_sys_max_cmd_len"; then
     4605      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
     4606      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
     4607    else
     4608      # Make teststring a little bigger before we do anything with it.
     4609      # a 1K string should be a reasonable start.
     4610      for i in 1 2 3 4 5 6 7 8 ; do
     4611        teststring=$teststring$teststring
     4612      done
     4613      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
     4614      # If test is not a shell built-in, we'll probably end up computing a
     4615      # maximum length that is only half of the actual maximum length, but
     4616      # we can't tell.
     4617      while { test "X"`$SHELL $0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \
     4618                 = "XX$teststring$teststring"; } >/dev/null 2>&1 &&
     4619              test $i != 17 # 1/2 MB should be enough
     4620      do
     4621        i=`expr $i + 1`
     4622        teststring=$teststring$teststring
     4623      done
     4624      # Only check the string length outside the loop.
     4625      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
     4626      teststring=
     4627      # Add a significant safety factor because C++ compilers can tack on
     4628      # massive amounts of additional arguments before passing them to the
     4629      # linker.  It appears as though 1/2 is a usable value.
     4630      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
     4631    fi
     4632    ;;
     4633  esac
     4634
     4635fi
     4636
     4637if test -n $lt_cv_sys_max_cmd_len ; then
     4638  { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
     4639echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
     4640else
     4641  { echo "$as_me:$LINENO: result: none" >&5
     4642echo "${ECHO_T}none" >&6; }
     4643fi
     4644max_cmd_len=$lt_cv_sys_max_cmd_len
     4645
     4646
     4647
     4648
     4649
     4650
     4651: ${CP="cp -f"}
     4652: ${MV="mv -f"}
     4653: ${RM="rm -f"}
     4654
     4655{ echo "$as_me:$LINENO: checking whether the shell understands some XSI constructs" >&5
     4656echo $ECHO_N "checking whether the shell understands some XSI constructs... $ECHO_C" >&6; }
     4657# Try some XSI features
     4658xsi_shell=no
     4659( _lt_dummy="a/b/c"
     4660  test "${_lt_dummy##*/},${_lt_dummy%/*},"${_lt_dummy%"$_lt_dummy"}, \
     4661      = c,a/b,, \
     4662    && eval 'test $(( 1 + 1 )) -eq 2 \
     4663    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
     4664  && xsi_shell=yes
     4665{ echo "$as_me:$LINENO: result: $xsi_shell" >&5
     4666echo "${ECHO_T}$xsi_shell" >&6; }
     4667
     4668
     4669{ echo "$as_me:$LINENO: checking whether the shell understands \"+=\"" >&5
     4670echo $ECHO_N "checking whether the shell understands \"+=\"... $ECHO_C" >&6; }
     4671lt_shell_append=no
     4672( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
     4673    >/dev/null 2>&1 \
     4674  && lt_shell_append=yes
     4675{ echo "$as_me:$LINENO: result: $lt_shell_append" >&5
     4676echo "${ECHO_T}$lt_shell_append" >&6; }
     4677
     4678
     4679if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
     4680  lt_unset=unset
     4681else
     4682  lt_unset=false
     4683fi
     4684
     4685
     4686
     4687
     4688
     4689# test EBCDIC or ASCII
     4690case `echo X|tr X '\101'` in
     4691 A) # ASCII based system
     4692    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
     4693  lt_SP2NL='tr \040 \012'
     4694  lt_NL2SP='tr \015\012 \040\040'
     4695  ;;
     4696 *) # EBCDIC based system
     4697  lt_SP2NL='tr \100 \n'
     4698  lt_NL2SP='tr \r\n \100\100'
     4699  ;;
     4700esac
     4701
     4702
     4703
     4704
     4705
     4706
     4707
     4708
     4709
     4710{ echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
     4711echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6; }
     4712if test "${lt_cv_ld_reload_flag+set}" = set; then
     4713  echo $ECHO_N "(cached) $ECHO_C" >&6
     4714else
     4715  lt_cv_ld_reload_flag='-r'
     4716fi
     4717{ echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
     4718echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6; }
     4719reload_flag=$lt_cv_ld_reload_flag
     4720case $reload_flag in
     4721"" | " "*) ;;
     4722*) reload_flag=" $reload_flag" ;;
     4723esac
     4724reload_cmds='$LD$reload_flag -o $output$reload_objs'
     4725case $host_os in
     4726  darwin*)
     4727    if test "$GCC" = yes; then
     4728      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
     4729    else
     4730      reload_cmds='$LD$reload_flag -o $output$reload_objs'
     4731    fi
     4732    ;;
     4733esac
     4734
     4735
     4736
     4737
     4738
     4739
     4740
     4741
     4742
    43184743
    43194744{ echo "$as_me:$LINENO: checking how to recognize dependent libraries" >&5
     
    43754800
    43764801freebsd* | dragonfly*)
    4377   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
     4802  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    43784803    case $host_cpu in
    43794804    i*86 )
     
    44334858
    44344859netbsd* | netbsdelf*-gnu)
    4435   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
     4860  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    44364861    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
    44374862  else
     
    44464871  ;;
    44474872
    4448 nto-qnx*)
    4449   lt_cv_deplibs_check_method=unknown
     4873*nto* | *qnx*)
     4874  lt_cv_deplibs_check_method=pass_all
    44504875  ;;
    44514876
    44524877openbsd*)
    4453   if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
     4878  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
    44544879    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
    44554880  else
     
    44674892
    44684893solaris*)
     4894  lt_cv_deplibs_check_method=pass_all
     4895  ;;
     4896
     4897sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
    44694898  lt_cv_deplibs_check_method=pass_all
    44704899  ;;
     
    44974926  ;;
    44984927
    4499 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
     4928tpf*)
    45004929  lt_cv_deplibs_check_method=pass_all
    45014930  ;;
     
    45124941
    45134942
     4943
     4944
     4945
     4946
     4947
     4948
     4949
     4950
     4951if test -n "$ac_tool_prefix"; then
     4952  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
     4953set dummy ${ac_tool_prefix}ar; ac_word=$2
     4954{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     4955echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     4956if test "${ac_cv_prog_AR+set}" = set; then
     4957  echo $ECHO_N "(cached) $ECHO_C" >&6
     4958else
     4959  if test -n "$AR"; then
     4960  ac_cv_prog_AR="$AR" # Let the user override the test.
     4961else
     4962as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4963for as_dir in $PATH
     4964do
     4965  IFS=$as_save_IFS
     4966  test -z "$as_dir" && as_dir=.
     4967  for ac_exec_ext in '' $ac_executable_extensions; do
     4968  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4969    ac_cv_prog_AR="${ac_tool_prefix}ar"
     4970    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     4971    break 2
     4972  fi
     4973done
     4974done
     4975IFS=$as_save_IFS
     4976
     4977fi
     4978fi
     4979AR=$ac_cv_prog_AR
     4980if test -n "$AR"; then
     4981  { echo "$as_me:$LINENO: result: $AR" >&5
     4982echo "${ECHO_T}$AR" >&6; }
     4983else
     4984  { echo "$as_me:$LINENO: result: no" >&5
     4985echo "${ECHO_T}no" >&6; }
     4986fi
     4987
     4988
     4989fi
     4990if test -z "$ac_cv_prog_AR"; then
     4991  ac_ct_AR=$AR
     4992  # Extract the first word of "ar", so it can be a program name with args.
     4993set dummy ar; ac_word=$2
     4994{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     4995echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     4996if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
     4997  echo $ECHO_N "(cached) $ECHO_C" >&6
     4998else
     4999  if test -n "$ac_ct_AR"; then
     5000  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
     5001else
     5002as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5003for as_dir in $PATH
     5004do
     5005  IFS=$as_save_IFS
     5006  test -z "$as_dir" && as_dir=.
     5007  for ac_exec_ext in '' $ac_executable_extensions; do
     5008  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5009    ac_cv_prog_ac_ct_AR="ar"
     5010    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5011    break 2
     5012  fi
     5013done
     5014done
     5015IFS=$as_save_IFS
     5016
     5017fi
     5018fi
     5019ac_ct_AR=$ac_cv_prog_ac_ct_AR
     5020if test -n "$ac_ct_AR"; then
     5021  { echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
     5022echo "${ECHO_T}$ac_ct_AR" >&6; }
     5023else
     5024  { echo "$as_me:$LINENO: result: no" >&5
     5025echo "${ECHO_T}no" >&6; }
     5026fi
     5027
     5028  if test "x$ac_ct_AR" = x; then
     5029    AR="false"
     5030  else
     5031    case $cross_compiling:$ac_tool_warned in
     5032yes:)
     5033{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     5034whose name does not start with the host triplet.  If you think this
     5035configuration is useful to you, please write to autoconf@gnu.org." >&5
     5036echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     5037whose name does not start with the host triplet.  If you think this
     5038configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     5039ac_tool_warned=yes ;;
     5040esac
     5041    AR=$ac_ct_AR
     5042  fi
     5043else
     5044  AR="$ac_cv_prog_AR"
     5045fi
     5046
     5047test -z "$AR" && AR=ar
     5048test -z "$AR_FLAGS" && AR_FLAGS=cru
     5049
     5050
     5051
     5052
     5053
     5054
     5055
     5056
     5057
     5058
     5059
     5060if test -n "$ac_tool_prefix"; then
     5061  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
     5062set dummy ${ac_tool_prefix}strip; ac_word=$2
     5063{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5064echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5065if test "${ac_cv_prog_STRIP+set}" = set; then
     5066  echo $ECHO_N "(cached) $ECHO_C" >&6
     5067else
     5068  if test -n "$STRIP"; then
     5069  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
     5070else
     5071as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5072for as_dir in $PATH
     5073do
     5074  IFS=$as_save_IFS
     5075  test -z "$as_dir" && as_dir=.
     5076  for ac_exec_ext in '' $ac_executable_extensions; do
     5077  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5078    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
     5079    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5080    break 2
     5081  fi
     5082done
     5083done
     5084IFS=$as_save_IFS
     5085
     5086fi
     5087fi
     5088STRIP=$ac_cv_prog_STRIP
     5089if test -n "$STRIP"; then
     5090  { echo "$as_me:$LINENO: result: $STRIP" >&5
     5091echo "${ECHO_T}$STRIP" >&6; }
     5092else
     5093  { echo "$as_me:$LINENO: result: no" >&5
     5094echo "${ECHO_T}no" >&6; }
     5095fi
     5096
     5097
     5098fi
     5099if test -z "$ac_cv_prog_STRIP"; then
     5100  ac_ct_STRIP=$STRIP
     5101  # Extract the first word of "strip", so it can be a program name with args.
     5102set dummy strip; ac_word=$2
     5103{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5104echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5105if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
     5106  echo $ECHO_N "(cached) $ECHO_C" >&6
     5107else
     5108  if test -n "$ac_ct_STRIP"; then
     5109  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
     5110else
     5111as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5112for as_dir in $PATH
     5113do
     5114  IFS=$as_save_IFS
     5115  test -z "$as_dir" && as_dir=.
     5116  for ac_exec_ext in '' $ac_executable_extensions; do
     5117  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5118    ac_cv_prog_ac_ct_STRIP="strip"
     5119    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5120    break 2
     5121  fi
     5122done
     5123done
     5124IFS=$as_save_IFS
     5125
     5126fi
     5127fi
     5128ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
     5129if test -n "$ac_ct_STRIP"; then
     5130  { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
     5131echo "${ECHO_T}$ac_ct_STRIP" >&6; }
     5132else
     5133  { echo "$as_me:$LINENO: result: no" >&5
     5134echo "${ECHO_T}no" >&6; }
     5135fi
     5136
     5137  if test "x$ac_ct_STRIP" = x; then
     5138    STRIP=":"
     5139  else
     5140    case $cross_compiling:$ac_tool_warned in
     5141yes:)
     5142{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     5143whose name does not start with the host triplet.  If you think this
     5144configuration is useful to you, please write to autoconf@gnu.org." >&5
     5145echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     5146whose name does not start with the host triplet.  If you think this
     5147configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     5148ac_tool_warned=yes ;;
     5149esac
     5150    STRIP=$ac_ct_STRIP
     5151  fi
     5152else
     5153  STRIP="$ac_cv_prog_STRIP"
     5154fi
     5155
     5156test -z "$STRIP" && STRIP=:
     5157
     5158
     5159
     5160
     5161
     5162
     5163if test -n "$ac_tool_prefix"; then
     5164  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
     5165set dummy ${ac_tool_prefix}ranlib; ac_word=$2
     5166{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5167echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5168if test "${ac_cv_prog_RANLIB+set}" = set; then
     5169  echo $ECHO_N "(cached) $ECHO_C" >&6
     5170else
     5171  if test -n "$RANLIB"; then
     5172  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
     5173else
     5174as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5175for as_dir in $PATH
     5176do
     5177  IFS=$as_save_IFS
     5178  test -z "$as_dir" && as_dir=.
     5179  for ac_exec_ext in '' $ac_executable_extensions; do
     5180  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5181    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
     5182    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5183    break 2
     5184  fi
     5185done
     5186done
     5187IFS=$as_save_IFS
     5188
     5189fi
     5190fi
     5191RANLIB=$ac_cv_prog_RANLIB
     5192if test -n "$RANLIB"; then
     5193  { echo "$as_me:$LINENO: result: $RANLIB" >&5
     5194echo "${ECHO_T}$RANLIB" >&6; }
     5195else
     5196  { echo "$as_me:$LINENO: result: no" >&5
     5197echo "${ECHO_T}no" >&6; }
     5198fi
     5199
     5200
     5201fi
     5202if test -z "$ac_cv_prog_RANLIB"; then
     5203  ac_ct_RANLIB=$RANLIB
     5204  # Extract the first word of "ranlib", so it can be a program name with args.
     5205set dummy ranlib; ac_word=$2
     5206{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5207echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5208if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
     5209  echo $ECHO_N "(cached) $ECHO_C" >&6
     5210else
     5211  if test -n "$ac_ct_RANLIB"; then
     5212  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
     5213else
     5214as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5215for as_dir in $PATH
     5216do
     5217  IFS=$as_save_IFS
     5218  test -z "$as_dir" && as_dir=.
     5219  for ac_exec_ext in '' $ac_executable_extensions; do
     5220  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5221    ac_cv_prog_ac_ct_RANLIB="ranlib"
     5222    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5223    break 2
     5224  fi
     5225done
     5226done
     5227IFS=$as_save_IFS
     5228
     5229fi
     5230fi
     5231ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
     5232if test -n "$ac_ct_RANLIB"; then
     5233  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
     5234echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
     5235else
     5236  { echo "$as_me:$LINENO: result: no" >&5
     5237echo "${ECHO_T}no" >&6; }
     5238fi
     5239
     5240  if test "x$ac_ct_RANLIB" = x; then
     5241    RANLIB=":"
     5242  else
     5243    case $cross_compiling:$ac_tool_warned in
     5244yes:)
     5245{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     5246whose name does not start with the host triplet.  If you think this
     5247configuration is useful to you, please write to autoconf@gnu.org." >&5
     5248echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     5249whose name does not start with the host triplet.  If you think this
     5250configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     5251ac_tool_warned=yes ;;
     5252esac
     5253    RANLIB=$ac_ct_RANLIB
     5254  fi
     5255else
     5256  RANLIB="$ac_cv_prog_RANLIB"
     5257fi
     5258
     5259test -z "$RANLIB" && RANLIB=:
     5260
     5261
     5262
     5263
     5264
     5265
     5266# Determine commands to create old-style static archives.
     5267old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
     5268old_postinstall_cmds='chmod 644 $oldlib'
     5269old_postuninstall_cmds=
     5270
     5271if test -n "$RANLIB"; then
     5272  case $host_os in
     5273  openbsd*)
     5274    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
     5275    ;;
     5276  *)
     5277    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
     5278    ;;
     5279  esac
     5280  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
     5281fi
     5282
     5283
     5284
     5285
     5286
     5287
     5288
     5289
     5290
     5291
     5292
     5293
     5294
     5295
     5296
     5297
     5298
     5299
     5300
     5301
     5302
     5303
     5304
     5305
     5306
     5307
     5308
     5309
     5310
     5311
     5312
     5313
     5314
     5315
    45145316# If no C compiler was specified, use CC.
    45155317LTCC=${LTCC-"$CC"}
     
    45205322# Allow CC to be a program name with arguments.
    45215323compiler=$CC
     5324
     5325
     5326# Check for command to grab the raw symbol name followed by C symbol from nm.
     5327{ echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5
     5328echo $ECHO_N "checking command to parse $NM output from $compiler object... $ECHO_C" >&6; }
     5329if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
     5330  echo $ECHO_N "(cached) $ECHO_C" >&6
     5331else
     5332
     5333# These are sane defaults that work on at least a few old systems.
     5334# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
     5335
     5336# Character class describing NM global symbol codes.
     5337symcode='[BCDEGRST]'
     5338
     5339# Regexp to match symbols that can be accessed directly from C.
     5340sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
     5341
     5342# Define system-specific variables.
     5343case $host_os in
     5344aix*)
     5345  symcode='[BCDT]'
     5346  ;;
     5347cygwin* | mingw* | pw32*)
     5348  symcode='[ABCDGISTW]'
     5349  ;;
     5350hpux*)
     5351  if test "$host_cpu" = ia64; then
     5352    symcode='[ABCDEGRST]'
     5353  fi
     5354  ;;
     5355irix* | nonstopux*)
     5356  symcode='[BCDEGRST]'
     5357  ;;
     5358osf*)
     5359  symcode='[BCDEGQRST]'
     5360  ;;
     5361solaris*)
     5362  symcode='[BDRT]'
     5363  ;;
     5364sco3.2v5*)
     5365  symcode='[DT]'
     5366  ;;
     5367sysv4.2uw2*)
     5368  symcode='[DT]'
     5369  ;;
     5370sysv5* | sco5v6* | unixware* | OpenUNIX*)
     5371  symcode='[ABDT]'
     5372  ;;
     5373sysv4)
     5374  symcode='[DFNSTU]'
     5375  ;;
     5376esac
     5377
     5378# If we're using GNU nm, then use its standard symbol codes.
     5379case `$NM -V 2>&1` in
     5380*GNU* | *'with BFD'*)
     5381  symcode='[ABCDGIRSTW]' ;;
     5382esac
     5383
     5384# Transform an extracted symbol line into a proper C declaration.
     5385# Some systems (esp. on ia64) link data and code symbols differently,
     5386# so use this general approach.
     5387lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
     5388
     5389# Transform an extracted symbol line into symbol name and symbol address
     5390lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (void *) \&\2},/p'"
     5391lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"lib\2\", (void *) \&\2},/p'"
     5392
     5393# Handle CRLF in mingw tool chain
     5394opt_cr=
     5395case $build_os in
     5396mingw*)
     5397  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
     5398  ;;
     5399esac
     5400
     5401# Try without a prefix underscore, then with it.
     5402for ac_symprfx in "" "_"; do
     5403
     5404  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
     5405  symxfrm="\\1 $ac_symprfx\\2 \\2"
     5406
     5407  # Write the raw and C identifiers.
     5408  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
     5409    # Fake it for dumpbin and say T for any non-static function
     5410    # and D for any global variable.
     5411    # Also find C++ and __fastcall symbols from MSVC++,
     5412    # which start with @ or ?.
     5413    lt_cv_sys_global_symbol_pipe="$AWK '"\
     5414"     {last_section=section; section=\$ 3};"\
     5415"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
     5416"     \$ 0!~/External *\|/{next};"\
     5417"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
     5418"     {if(hide[section]) next};"\
     5419"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
     5420"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
     5421"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
     5422"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
     5423"     ' prfx=^$ac_symprfx"
     5424  else
     5425    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[      ]\($symcode$symcode*\)[         ][      ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
     5426  fi
     5427
     5428  # Check to see that the pipe works correctly.
     5429  pipe_works=no
     5430
     5431  rm -f conftest*
     5432  cat > conftest.$ac_ext <<_LT_EOF
     5433#ifdef __cplusplus
     5434extern "C" {
     5435#endif
     5436char nm_test_var;
     5437void nm_test_func(void);
     5438void nm_test_func(void){}
     5439#ifdef __cplusplus
     5440}
     5441#endif
     5442int main(){nm_test_var='a';nm_test_func();return(0);}
     5443_LT_EOF
     5444
     5445  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     5446  (eval $ac_compile) 2>&5
     5447  ac_status=$?
     5448  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     5449  (exit $ac_status); }; then
     5450    # Now try to grab the symbols.
     5451    nlist=conftest.nm
     5452    if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
     5453  (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
     5454  ac_status=$?
     5455  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     5456  (exit $ac_status); } && test -s "$nlist"; then
     5457      # Try sorting and uniquifying the output.
     5458      if sort "$nlist" | uniq > "$nlist"T; then
     5459        mv -f "$nlist"T "$nlist"
     5460      else
     5461        rm -f "$nlist"T
     5462      fi
     5463
     5464      # Make sure that we snagged all the symbols we need.
     5465      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
     5466        if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
     5467          cat <<_LT_EOF > conftest.$ac_ext
     5468#ifdef __cplusplus
     5469extern "C" {
     5470#endif
     5471
     5472_LT_EOF
     5473          # Now generate the symbol file.
     5474          eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
     5475
     5476          cat <<_LT_EOF >> conftest.$ac_ext
     5477
     5478/* The mapping between symbol names and symbols.  */
     5479const struct {
     5480  const char *name;
     5481  void       *address;
     5482}
     5483lt__PROGRAM__LTX_preloaded_symbols[] =
     5484{
     5485  { "@PROGRAM@", (void *) 0 },
     5486_LT_EOF
     5487          $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
     5488          cat <<\_LT_EOF >> conftest.$ac_ext
     5489  {0, (void *) 0}
     5490};
     5491
     5492/* This works around a problem in FreeBSD linker */
     5493#ifdef FREEBSD_WORKAROUND
     5494static const void *lt_preloaded_setup() {
     5495  return lt__PROGRAM__LTX_preloaded_symbols;
     5496}
     5497#endif
     5498
     5499#ifdef __cplusplus
     5500}
     5501#endif
     5502_LT_EOF
     5503          # Now try linking the two files.
     5504          mv conftest.$ac_objext conftstm.$ac_objext
     5505          lt_save_LIBS="$LIBS"
     5506          lt_save_CFLAGS="$CFLAGS"
     5507          LIBS="conftstm.$ac_objext"
     5508          CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
     5509          if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     5510  (eval $ac_link) 2>&5
     5511  ac_status=$?
     5512  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     5513  (exit $ac_status); } && test -s conftest${ac_exeext}; then
     5514            pipe_works=yes
     5515          fi
     5516          LIBS="$lt_save_LIBS"
     5517          CFLAGS="$lt_save_CFLAGS"
     5518        else
     5519          echo "cannot find nm_test_func in $nlist" >&5
     5520        fi
     5521      else
     5522        echo "cannot find nm_test_var in $nlist" >&5
     5523      fi
     5524    else
     5525      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
     5526    fi
     5527  else
     5528    echo "$progname: failed program was:" >&5
     5529    cat conftest.$ac_ext >&5
     5530  fi
     5531  rm -rf conftest* conftst*
     5532
     5533  # Do not use the global_symbol_pipe unless it works.
     5534  if test "$pipe_works" = yes; then
     5535    break
     5536  else
     5537    lt_cv_sys_global_symbol_pipe=
     5538  fi
     5539done
     5540
     5541fi
     5542
     5543if test -z "$lt_cv_sys_global_symbol_pipe"; then
     5544  lt_cv_sys_global_symbol_to_cdecl=
     5545fi
     5546if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
     5547  { echo "$as_me:$LINENO: result: failed" >&5
     5548echo "${ECHO_T}failed" >&6; }
     5549else
     5550  { echo "$as_me:$LINENO: result: ok" >&5
     5551echo "${ECHO_T}ok" >&6; }
     5552fi
     5553
     5554
     5555
     5556
     5557
     5558
     5559
     5560
     5561
     5562
     5563
     5564
     5565
     5566
     5567
     5568
     5569
     5570
     5571
     5572
     5573
    45225574
    45235575
     
    45415593  (exit $ac_status); }; then
    45425594    case `/usr/bin/file conftest.$ac_objext` in
    4543     *ELF-32*)
    4544       HPUX_IA64_MODE="32"
    4545       ;;
    4546     *ELF-64*)
    4547       HPUX_IA64_MODE="64"
    4548       ;;
     5595      *ELF-32*)
     5596        HPUX_IA64_MODE="32"
     5597        ;;
     5598      *ELF-64*)
     5599        HPUX_IA64_MODE="64"
     5600        ;;
    45495601    esac
    45505602  fi
     
    45535605*-*-irix6*)
    45545606  # Find out which ABI we are using.
    4555   echo '#line 4555 "configure"' > conftest.$ac_ext
     5607  echo '#line 5607 "configure"' > conftest.$ac_ext
    45565608  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
    45575609  (eval $ac_compile) 2>&5
     
    45595611  echo "$as_me:$LINENO: \$? = $ac_status" >&5
    45605612  (exit $ac_status); }; then
    4561    if test "$lt_cv_prog_gnu_ld" = yes; then
    4562     case `/usr/bin/file conftest.$ac_objext` in
    4563     *32-bit*)
    4564       LD="${LD-ld} -melf32bsmip"
    4565       ;;
    4566     *N32*)
    4567       LD="${LD-ld} -melf32bmipn32"
    4568       ;;
    4569     *64-bit*)
    4570       LD="${LD-ld} -melf64bmip"
    4571       ;;
    4572     esac
    4573    else
    4574     case `/usr/bin/file conftest.$ac_objext` in
    4575     *32-bit*)
    4576       LD="${LD-ld} -32"
    4577       ;;
    4578     *N32*)
    4579       LD="${LD-ld} -n32"
    4580       ;;
    4581     *64-bit*)
    4582       LD="${LD-ld} -64"
    4583       ;;
    4584     esac
    4585    fi
     5613    if test "$lt_cv_prog_gnu_ld" = yes; then
     5614      case `/usr/bin/file conftest.$ac_objext` in
     5615        *32-bit*)
     5616          LD="${LD-ld} -melf32bsmip"
     5617          ;;
     5618        *N32*)
     5619          LD="${LD-ld} -melf32bmipn32"
     5620          ;;
     5621        *64-bit*)
     5622          LD="${LD-ld} -melf64bmip"
     5623        ;;
     5624      esac
     5625    else
     5626      case `/usr/bin/file conftest.$ac_objext` in
     5627        *32-bit*)
     5628          LD="${LD-ld} -32"
     5629          ;;
     5630        *N32*)
     5631          LD="${LD-ld} -n32"
     5632          ;;
     5633        *64-bit*)
     5634          LD="${LD-ld} -64"
     5635          ;;
     5636      esac
     5637    fi
    45865638  fi
    45875639  rm -rf conftest*
     
    45895641
    45905642x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
    4591 s390*-*linux*|sparc*-*linux*)
     5643s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
    45925644  # Find out which ABI we are using.
    45935645  echo 'int i;' > conftest.$ac_ext
     
    45985650  (exit $ac_status); }; then
    45995651    case `/usr/bin/file conftest.o` in
    4600     *32-bit*)
    4601       case $host in
    4602         x86_64-*kfreebsd*-gnu)
    4603           LD="${LD-ld} -m elf_i386_fbsd"
    4604           ;;
    4605         x86_64-*linux*)
    4606           LD="${LD-ld} -m elf_i386"
    4607           ;;
    4608         ppc64-*linux*|powerpc64-*linux*)
    4609           LD="${LD-ld} -m elf32ppclinux"
    4610           ;;
    4611         s390x-*linux*)
    4612           LD="${LD-ld} -m elf_s390"
    4613           ;;
    4614         sparc64-*linux*)
    4615           LD="${LD-ld} -m elf32_sparc"
    4616           ;;
    4617       esac
    4618       ;;
    4619     *64-bit*)
    4620       case $host in
    4621         x86_64-*kfreebsd*-gnu)
    4622           LD="${LD-ld} -m elf_x86_64_fbsd"
    4623           ;;
    4624         x86_64-*linux*)
    4625           LD="${LD-ld} -m elf_x86_64"
    4626           ;;
    4627         ppc*-*linux*|powerpc*-*linux*)
    4628           LD="${LD-ld} -m elf64ppc"
    4629           ;;
    4630         s390*-*linux*)
    4631           LD="${LD-ld} -m elf64_s390"
    4632           ;;
    4633         sparc*-*linux*)
    4634           LD="${LD-ld} -m elf64_sparc"
    4635           ;;
    4636       esac
    4637       ;;
     5652      *32-bit*)
     5653        case $host in
     5654          x86_64-*kfreebsd*-gnu)
     5655            LD="${LD-ld} -m elf_i386_fbsd"
     5656            ;;
     5657          x86_64-*linux*)
     5658            LD="${LD-ld} -m elf_i386"
     5659            ;;
     5660          ppc64-*linux*|powerpc64-*linux*)
     5661            LD="${LD-ld} -m elf32ppclinux"
     5662            ;;
     5663          s390x-*linux*)
     5664            LD="${LD-ld} -m elf_s390"
     5665            ;;
     5666          sparc64-*linux*)
     5667            LD="${LD-ld} -m elf32_sparc"
     5668            ;;
     5669        esac
     5670        ;;
     5671      *64-bit*)
     5672        case $host in
     5673          x86_64-*kfreebsd*-gnu)
     5674            LD="${LD-ld} -m elf_x86_64_fbsd"
     5675            ;;
     5676          x86_64-*linux*)
     5677            LD="${LD-ld} -m elf_x86_64"
     5678            ;;
     5679          ppc*-*linux*|powerpc*-*linux*)
     5680            LD="${LD-ld} -m elf64ppc"
     5681            ;;
     5682          s390*-*linux*|s390*-*tpf*)
     5683            LD="${LD-ld} -m elf64_s390"
     5684            ;;
     5685          sparc*-*linux*)
     5686            LD="${LD-ld} -m elf64_sparc"
     5687            ;;
     5688        esac
     5689        ;;
    46385690    esac
    46395691  fi
     
    47265778      yes*) LD="${LD-ld} -m elf64_sparc" ;;
    47275779      *)
    4728         if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
     5780        if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
    47295781          LD="${LD-ld} -64"
    47305782        fi
     
    47365788  rm -rf conftest*
    47375789  ;;
    4738 
    4739 
    47405790esac
    47415791
    47425792need_locks="$enable_libtool_lock"
    47435793
     5794
     5795  case $host_os in
     5796    rhapsody* | darwin*)
     5797    if test -n "$ac_tool_prefix"; then
     5798  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
     5799set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
     5800{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5801echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5802if test "${ac_cv_prog_DSYMUTIL+set}" = set; then
     5803  echo $ECHO_N "(cached) $ECHO_C" >&6
     5804else
     5805  if test -n "$DSYMUTIL"; then
     5806  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
     5807else
     5808as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5809for as_dir in $PATH
     5810do
     5811  IFS=$as_save_IFS
     5812  test -z "$as_dir" && as_dir=.
     5813  for ac_exec_ext in '' $ac_executable_extensions; do
     5814  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5815    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
     5816    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5817    break 2
     5818  fi
     5819done
     5820done
     5821IFS=$as_save_IFS
     5822
     5823fi
     5824fi
     5825DSYMUTIL=$ac_cv_prog_DSYMUTIL
     5826if test -n "$DSYMUTIL"; then
     5827  { echo "$as_me:$LINENO: result: $DSYMUTIL" >&5
     5828echo "${ECHO_T}$DSYMUTIL" >&6; }
     5829else
     5830  { echo "$as_me:$LINENO: result: no" >&5
     5831echo "${ECHO_T}no" >&6; }
     5832fi
     5833
     5834
     5835fi
     5836if test -z "$ac_cv_prog_DSYMUTIL"; then
     5837  ac_ct_DSYMUTIL=$DSYMUTIL
     5838  # Extract the first word of "dsymutil", so it can be a program name with args.
     5839set dummy dsymutil; ac_word=$2
     5840{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5841echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5842if test "${ac_cv_prog_ac_ct_DSYMUTIL+set}" = set; then
     5843  echo $ECHO_N "(cached) $ECHO_C" >&6
     5844else
     5845  if test -n "$ac_ct_DSYMUTIL"; then
     5846  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
     5847else
     5848as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5849for as_dir in $PATH
     5850do
     5851  IFS=$as_save_IFS
     5852  test -z "$as_dir" && as_dir=.
     5853  for ac_exec_ext in '' $ac_executable_extensions; do
     5854  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5855    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
     5856    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5857    break 2
     5858  fi
     5859done
     5860done
     5861IFS=$as_save_IFS
     5862
     5863fi
     5864fi
     5865ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
     5866if test -n "$ac_ct_DSYMUTIL"; then
     5867  { echo "$as_me:$LINENO: result: $ac_ct_DSYMUTIL" >&5
     5868echo "${ECHO_T}$ac_ct_DSYMUTIL" >&6; }
     5869else
     5870  { echo "$as_me:$LINENO: result: no" >&5
     5871echo "${ECHO_T}no" >&6; }
     5872fi
     5873
     5874  if test "x$ac_ct_DSYMUTIL" = x; then
     5875    DSYMUTIL=":"
     5876  else
     5877    case $cross_compiling:$ac_tool_warned in
     5878yes:)
     5879{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     5880whose name does not start with the host triplet.  If you think this
     5881configuration is useful to you, please write to autoconf@gnu.org." >&5
     5882echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     5883whose name does not start with the host triplet.  If you think this
     5884configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     5885ac_tool_warned=yes ;;
     5886esac
     5887    DSYMUTIL=$ac_ct_DSYMUTIL
     5888  fi
     5889else
     5890  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
     5891fi
     5892
     5893    if test -n "$ac_tool_prefix"; then
     5894  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
     5895set dummy ${ac_tool_prefix}nmedit; ac_word=$2
     5896{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5897echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5898if test "${ac_cv_prog_NMEDIT+set}" = set; then
     5899  echo $ECHO_N "(cached) $ECHO_C" >&6
     5900else
     5901  if test -n "$NMEDIT"; then
     5902  ac_cv_prog_NMEDIT="$NMEDIT" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5911    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
     5912    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5913    break 2
     5914  fi
     5915done
     5916done
     5917IFS=$as_save_IFS
     5918
     5919fi
     5920fi
     5921NMEDIT=$ac_cv_prog_NMEDIT
     5922if test -n "$NMEDIT"; then
     5923  { echo "$as_me:$LINENO: result: $NMEDIT" >&5
     5924echo "${ECHO_T}$NMEDIT" >&6; }
     5925else
     5926  { echo "$as_me:$LINENO: result: no" >&5
     5927echo "${ECHO_T}no" >&6; }
     5928fi
     5929
     5930
     5931fi
     5932if test -z "$ac_cv_prog_NMEDIT"; then
     5933  ac_ct_NMEDIT=$NMEDIT
     5934  # Extract the first word of "nmedit", so it can be a program name with args.
     5935set dummy nmedit; ac_word=$2
     5936{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5937echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5938if test "${ac_cv_prog_ac_ct_NMEDIT+set}" = set; then
     5939  echo $ECHO_N "(cached) $ECHO_C" >&6
     5940else
     5941  if test -n "$ac_ct_NMEDIT"; then
     5942  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
     5943else
     5944as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5945for as_dir in $PATH
     5946do
     5947  IFS=$as_save_IFS
     5948  test -z "$as_dir" && as_dir=.
     5949  for ac_exec_ext in '' $ac_executable_extensions; do
     5950  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     5951    ac_cv_prog_ac_ct_NMEDIT="nmedit"
     5952    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     5953    break 2
     5954  fi
     5955done
     5956done
     5957IFS=$as_save_IFS
     5958
     5959fi
     5960fi
     5961ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
     5962if test -n "$ac_ct_NMEDIT"; then
     5963  { echo "$as_me:$LINENO: result: $ac_ct_NMEDIT" >&5
     5964echo "${ECHO_T}$ac_ct_NMEDIT" >&6; }
     5965else
     5966  { echo "$as_me:$LINENO: result: no" >&5
     5967echo "${ECHO_T}no" >&6; }
     5968fi
     5969
     5970  if test "x$ac_ct_NMEDIT" = x; then
     5971    NMEDIT=":"
     5972  else
     5973    case $cross_compiling:$ac_tool_warned in
     5974yes:)
     5975{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     5976whose name does not start with the host triplet.  If you think this
     5977configuration is useful to you, please write to autoconf@gnu.org." >&5
     5978echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     5979whose name does not start with the host triplet.  If you think this
     5980configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     5981ac_tool_warned=yes ;;
     5982esac
     5983    NMEDIT=$ac_ct_NMEDIT
     5984  fi
     5985else
     5986  NMEDIT="$ac_cv_prog_NMEDIT"
     5987fi
     5988
     5989    if test -n "$ac_tool_prefix"; then
     5990  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
     5991set dummy ${ac_tool_prefix}lipo; ac_word=$2
     5992{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     5993echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     5994if test "${ac_cv_prog_LIPO+set}" = set; then
     5995  echo $ECHO_N "(cached) $ECHO_C" >&6
     5996else
     5997  if test -n "$LIPO"; then
     5998  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
     5999else
     6000as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     6001for as_dir in $PATH
     6002do
     6003  IFS=$as_save_IFS
     6004  test -z "$as_dir" && as_dir=.
     6005  for ac_exec_ext in '' $ac_executable_extensions; do
     6006  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     6007    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
     6008    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     6009    break 2
     6010  fi
     6011done
     6012done
     6013IFS=$as_save_IFS
     6014
     6015fi
     6016fi
     6017LIPO=$ac_cv_prog_LIPO
     6018if test -n "$LIPO"; then
     6019  { echo "$as_me:$LINENO: result: $LIPO" >&5
     6020echo "${ECHO_T}$LIPO" >&6; }
     6021else
     6022  { echo "$as_me:$LINENO: result: no" >&5
     6023echo "${ECHO_T}no" >&6; }
     6024fi
     6025
     6026
     6027fi
     6028if test -z "$ac_cv_prog_LIPO"; then
     6029  ac_ct_LIPO=$LIPO
     6030  # Extract the first word of "lipo", so it can be a program name with args.
     6031set dummy lipo; ac_word=$2
     6032{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     6033echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     6034if test "${ac_cv_prog_ac_ct_LIPO+set}" = set; then
     6035  echo $ECHO_N "(cached) $ECHO_C" >&6
     6036else
     6037  if test -n "$ac_ct_LIPO"; then
     6038  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
     6039else
     6040as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     6041for as_dir in $PATH
     6042do
     6043  IFS=$as_save_IFS
     6044  test -z "$as_dir" && as_dir=.
     6045  for ac_exec_ext in '' $ac_executable_extensions; do
     6046  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     6047    ac_cv_prog_ac_ct_LIPO="lipo"
     6048    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     6049    break 2
     6050  fi
     6051done
     6052done
     6053IFS=$as_save_IFS
     6054
     6055fi
     6056fi
     6057ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
     6058if test -n "$ac_ct_LIPO"; then
     6059  { echo "$as_me:$LINENO: result: $ac_ct_LIPO" >&5
     6060echo "${ECHO_T}$ac_ct_LIPO" >&6; }
     6061else
     6062  { echo "$as_me:$LINENO: result: no" >&5
     6063echo "${ECHO_T}no" >&6; }
     6064fi
     6065
     6066  if test "x$ac_ct_LIPO" = x; then
     6067    LIPO=":"
     6068  else
     6069    case $cross_compiling:$ac_tool_warned in
     6070yes:)
     6071{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     6072whose name does not start with the host triplet.  If you think this
     6073configuration is useful to you, please write to autoconf@gnu.org." >&5
     6074echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     6075whose name does not start with the host triplet.  If you think this
     6076configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     6077ac_tool_warned=yes ;;
     6078esac
     6079    LIPO=$ac_ct_LIPO
     6080  fi
     6081else
     6082  LIPO="$ac_cv_prog_LIPO"
     6083fi
     6084
     6085    if test -n "$ac_tool_prefix"; then
     6086  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
     6087set dummy ${ac_tool_prefix}otool; ac_word=$2
     6088{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     6089echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     6090if test "${ac_cv_prog_OTOOL+set}" = set; then
     6091  echo $ECHO_N "(cached) $ECHO_C" >&6
     6092else
     6093  if test -n "$OTOOL"; then
     6094  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
     6095else
     6096as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     6097for as_dir in $PATH
     6098do
     6099  IFS=$as_save_IFS
     6100  test -z "$as_dir" && as_dir=.
     6101  for ac_exec_ext in '' $ac_executable_extensions; do
     6102  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     6103    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
     6104    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     6105    break 2
     6106  fi
     6107done
     6108done
     6109IFS=$as_save_IFS
     6110
     6111fi
     6112fi
     6113OTOOL=$ac_cv_prog_OTOOL
     6114if test -n "$OTOOL"; then
     6115  { echo "$as_me:$LINENO: result: $OTOOL" >&5
     6116echo "${ECHO_T}$OTOOL" >&6; }
     6117else
     6118  { echo "$as_me:$LINENO: result: no" >&5
     6119echo "${ECHO_T}no" >&6; }
     6120fi
     6121
     6122
     6123fi
     6124if test -z "$ac_cv_prog_OTOOL"; then
     6125  ac_ct_OTOOL=$OTOOL
     6126  # Extract the first word of "otool", so it can be a program name with args.
     6127set dummy otool; ac_word=$2
     6128{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     6129echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     6130if test "${ac_cv_prog_ac_ct_OTOOL+set}" = set; then
     6131  echo $ECHO_N "(cached) $ECHO_C" >&6
     6132else
     6133  if test -n "$ac_ct_OTOOL"; then
     6134  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
     6135else
     6136as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     6137for as_dir in $PATH
     6138do
     6139  IFS=$as_save_IFS
     6140  test -z "$as_dir" && as_dir=.
     6141  for ac_exec_ext in '' $ac_executable_extensions; do
     6142  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     6143    ac_cv_prog_ac_ct_OTOOL="otool"
     6144    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     6145    break 2
     6146  fi
     6147done
     6148done
     6149IFS=$as_save_IFS
     6150
     6151fi
     6152fi
     6153ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
     6154if test -n "$ac_ct_OTOOL"; then
     6155  { echo "$as_me:$LINENO: result: $ac_ct_OTOOL" >&5
     6156echo "${ECHO_T}$ac_ct_OTOOL" >&6; }
     6157else
     6158  { echo "$as_me:$LINENO: result: no" >&5
     6159echo "${ECHO_T}no" >&6; }
     6160fi
     6161
     6162  if test "x$ac_ct_OTOOL" = x; then
     6163    OTOOL=":"
     6164  else
     6165    case $cross_compiling:$ac_tool_warned in
     6166yes:)
     6167{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     6168whose name does not start with the host triplet.  If you think this
     6169configuration is useful to you, please write to autoconf@gnu.org." >&5
     6170echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     6171whose name does not start with the host triplet.  If you think this
     6172configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     6173ac_tool_warned=yes ;;
     6174esac
     6175    OTOOL=$ac_ct_OTOOL
     6176  fi
     6177else
     6178  OTOOL="$ac_cv_prog_OTOOL"
     6179fi
     6180
     6181    if test -n "$ac_tool_prefix"; then
     6182  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
     6183set dummy ${ac_tool_prefix}otool64; ac_word=$2
     6184{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     6185echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     6186if test "${ac_cv_prog_OTOOL64+set}" = set; then
     6187  echo $ECHO_N "(cached) $ECHO_C" >&6
     6188else
     6189  if test -n "$OTOOL64"; then
     6190  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
     6191else
     6192as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     6193for as_dir in $PATH
     6194do
     6195  IFS=$as_save_IFS
     6196  test -z "$as_dir" && as_dir=.
     6197  for ac_exec_ext in '' $ac_executable_extensions; do
     6198  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     6199    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
     6200    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     6201    break 2
     6202  fi
     6203done
     6204done
     6205IFS=$as_save_IFS
     6206
     6207fi
     6208fi
     6209OTOOL64=$ac_cv_prog_OTOOL64
     6210if test -n "$OTOOL64"; then
     6211  { echo "$as_me:$LINENO: result: $OTOOL64" >&5
     6212echo "${ECHO_T}$OTOOL64" >&6; }
     6213else
     6214  { echo "$as_me:$LINENO: result: no" >&5
     6215echo "${ECHO_T}no" >&6; }
     6216fi
     6217
     6218
     6219fi
     6220if test -z "$ac_cv_prog_OTOOL64"; then
     6221  ac_ct_OTOOL64=$OTOOL64
     6222  # Extract the first word of "otool64", so it can be a program name with args.
     6223set dummy otool64; ac_word=$2
     6224{ echo "$as_me:$LINENO: checking for $ac_word" >&5
     6225echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
     6226if test "${ac_cv_prog_ac_ct_OTOOL64+set}" = set; then
     6227  echo $ECHO_N "(cached) $ECHO_C" >&6
     6228else
     6229  if test -n "$ac_ct_OTOOL64"; then
     6230  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
     6231else
     6232as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     6233for as_dir in $PATH
     6234do
     6235  IFS=$as_save_IFS
     6236  test -z "$as_dir" && as_dir=.
     6237  for ac_exec_ext in '' $ac_executable_extensions; do
     6238  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     6239    ac_cv_prog_ac_ct_OTOOL64="otool64"
     6240    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     6241    break 2
     6242  fi
     6243done
     6244done
     6245IFS=$as_save_IFS
     6246
     6247fi
     6248fi
     6249ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
     6250if test -n "$ac_ct_OTOOL64"; then
     6251  { echo "$as_me:$LINENO: result: $ac_ct_OTOOL64" >&5
     6252echo "${ECHO_T}$ac_ct_OTOOL64" >&6; }
     6253else
     6254  { echo "$as_me:$LINENO: result: no" >&5
     6255echo "${ECHO_T}no" >&6; }
     6256fi
     6257
     6258  if test "x$ac_ct_OTOOL64" = x; then
     6259    OTOOL64=":"
     6260  else
     6261    case $cross_compiling:$ac_tool_warned in
     6262yes:)
     6263{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     6264whose name does not start with the host triplet.  If you think this
     6265configuration is useful to you, please write to autoconf@gnu.org." >&5
     6266echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     6267whose name does not start with the host triplet.  If you think this
     6268configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     6269ac_tool_warned=yes ;;
     6270esac
     6271    OTOOL64=$ac_ct_OTOOL64
     6272  fi
     6273else
     6274  OTOOL64="$ac_cv_prog_OTOOL64"
     6275fi
     6276
     6277
     6278
     6279
     6280
     6281
     6282
     6283
     6284
     6285
     6286
     6287
     6288
     6289
     6290
     6291
     6292
     6293
     6294
     6295
     6296
     6297
     6298
     6299
     6300
     6301
     6302
     6303    { echo "$as_me:$LINENO: checking for -single_module linker flag" >&5
     6304echo $ECHO_N "checking for -single_module linker flag... $ECHO_C" >&6; }
     6305if test "${lt_cv_apple_cc_single_mod+set}" = set; then
     6306  echo $ECHO_N "(cached) $ECHO_C" >&6
     6307else
     6308  lt_cv_apple_cc_single_mod=no
     6309      if test -z "${LT_MULTI_MODULE}"; then
     6310        # By default we will add the -single_module flag. You can override
     6311        # by either setting the environment variable LT_MULTI_MODULE
     6312        # non-empty at configure time, or by adding -multi_module to the
     6313        # link flags.
     6314        rm -rf libconftest.dylib*
     6315        echo "int foo(void){return 1;}" > conftest.c
     6316        echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
     6317-dynamiclib -Wl,-single_module conftest.c" >&5
     6318        $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
     6319          -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
     6320        _lt_result=$?
     6321        if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then
     6322          lt_cv_apple_cc_single_mod=yes
     6323        else
     6324          cat conftest.err >&5
     6325        fi
     6326        rm -rf libconftest.dylib*
     6327        rm -f conftest.*
     6328      fi
     6329fi
     6330{ echo "$as_me:$LINENO: result: $lt_cv_apple_cc_single_mod" >&5
     6331echo "${ECHO_T}$lt_cv_apple_cc_single_mod" >&6; }
     6332    { echo "$as_me:$LINENO: checking for -exported_symbols_list linker flag" >&5
     6333echo $ECHO_N "checking for -exported_symbols_list linker flag... $ECHO_C" >&6; }
     6334if test "${lt_cv_ld_exported_symbols_list+set}" = set; then
     6335  echo $ECHO_N "(cached) $ECHO_C" >&6
     6336else
     6337  lt_cv_ld_exported_symbols_list=no
     6338      save_LDFLAGS=$LDFLAGS
     6339      echo "_main" > conftest.sym
     6340      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
     6341      cat >conftest.$ac_ext <<_ACEOF
     6342/* confdefs.h.  */
     6343_ACEOF
     6344cat confdefs.h >>conftest.$ac_ext
     6345cat >>conftest.$ac_ext <<_ACEOF
     6346/* end confdefs.h.  */
     6347
     6348int
     6349main ()
     6350{
     6351
     6352  ;
     6353  return 0;
     6354}
     6355_ACEOF
     6356rm -f conftest.$ac_objext conftest$ac_exeext
     6357if { (ac_try="$ac_link"
     6358case "(($ac_try" in
     6359  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     6360  *) ac_try_echo=$ac_try;;
     6361esac
     6362eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
     6363  (eval "$ac_link") 2>conftest.er1
     6364  ac_status=$?
     6365  grep -v '^ *+' conftest.er1 >conftest.err
     6366  rm -f conftest.er1
     6367  cat conftest.err >&5
     6368  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6369  (exit $ac_status); } && {
     6370         test -z "$ac_c_werror_flag" ||
     6371         test ! -s conftest.err
     6372       } && test -s conftest$ac_exeext &&
     6373       $as_test_x conftest$ac_exeext; then
     6374  lt_cv_ld_exported_symbols_list=yes
     6375else
     6376  echo "$as_me: failed program was:" >&5
     6377sed 's/^/| /' conftest.$ac_ext >&5
     6378
     6379        lt_cv_ld_exported_symbols_list=no
     6380fi
     6381
     6382rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
     6383      conftest$ac_exeext conftest.$ac_ext
     6384        LDFLAGS="$save_LDFLAGS"
     6385
     6386fi
     6387{ echo "$as_me:$LINENO: result: $lt_cv_ld_exported_symbols_list" >&5
     6388echo "${ECHO_T}$lt_cv_ld_exported_symbols_list" >&6; }
     6389    case $host_os in
     6390    rhapsody* | darwin1.[012])
     6391      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
     6392    darwin1.*)
     6393      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
     6394    darwin*) # darwin 5.x on
     6395      # if running on 10.5 or later, the deployment target defaults
     6396      # to the OS version, if on x86, and 10.4, the deployment
     6397      # target defaults to 10.4. Don't you love it?
     6398      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
     6399        10.0,*86*-darwin8*|10.0,*-darwin[91]*)
     6400          _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
     6401        10.[012]*)
     6402          _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
     6403        10.*)
     6404          _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
     6405      esac
     6406    ;;
     6407  esac
     6408    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
     6409      _lt_dar_single_mod='$single_module'
     6410    fi
     6411    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
     6412      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
     6413    else
     6414      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
     6415    fi
     6416    if test "$DSYMUTIL" != ":"; then
     6417      _lt_dsymutil='~$DSYMUTIL $lib || :'
     6418    else
     6419      _lt_dsymutil=
     6420    fi
     6421    ;;
     6422  esac
    47446423
    47456424ac_ext=c
     
    52216900do
    52226901as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
    5223 if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
    5224   { echo "$as_me:$LINENO: checking for $ac_header" >&5
     6902{ echo "$as_me:$LINENO: checking for $ac_header" >&5
    52256903echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
    52266904if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
    52276905  echo $ECHO_N "(cached) $ECHO_C" >&6
    5228 fi
    5229 ac_res=`eval echo '${'$as_ac_Header'}'`
    5230                { echo "$as_me:$LINENO: result: $ac_res" >&5
    5231 echo "${ECHO_T}$ac_res" >&6; }
    5232 else
    5233   # Is the header compilable?
    5234 { echo "$as_me:$LINENO: checking $ac_header usability" >&5
    5235 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
    5236 cat >conftest.$ac_ext <<_ACEOF
     6906else
     6907  cat >conftest.$ac_ext <<_ACEOF
    52376908/* confdefs.h.  */
    52386909_ACEOF
     
    52416912/* end confdefs.h.  */
    52426913$ac_includes_default
     6914
    52436915#include <$ac_header>
    52446916_ACEOF
     
    52606932         test ! -s conftest.err
    52616933       } && test -s conftest.$ac_objext; then
    5262   ac_header_compiler=yes
     6934  eval "$as_ac_Header=yes"
    52636935else
    52646936  echo "$as_me: failed program was:" >&5
    52656937sed 's/^/| /' conftest.$ac_ext >&5
    52666938
    5267         ac_header_compiler=no
     6939        eval "$as_ac_Header=no"
    52686940fi
    52696941
    52706942rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5271 { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
    5272 echo "${ECHO_T}$ac_header_compiler" >&6; }
    5273 
    5274 # Is the header present?
    5275 { echo "$as_me:$LINENO: checking $ac_header presence" >&5
    5276 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
    5277 cat >conftest.$ac_ext <<_ACEOF
    5278 /* confdefs.h.  */
    5279 _ACEOF
    5280 cat confdefs.h >>conftest.$ac_ext
    5281 cat >>conftest.$ac_ext <<_ACEOF
    5282 /* end confdefs.h.  */
    5283 #include <$ac_header>
    5284 _ACEOF
    5285 if { (ac_try="$ac_cpp conftest.$ac_ext"
    5286 case "(($ac_try" in
    5287   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5288   *) ac_try_echo=$ac_try;;
    5289 esac
    5290 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5291   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    5292   ac_status=$?
    5293   grep -v '^ *+' conftest.er1 >conftest.err
    5294   rm -f conftest.er1
    5295   cat conftest.err >&5
    5296   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5297   (exit $ac_status); } >/dev/null && {
    5298          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
    5299          test ! -s conftest.err
    5300        }; then
    5301   ac_header_preproc=yes
    5302 else
    5303   echo "$as_me: failed program was:" >&5
    5304 sed 's/^/| /' conftest.$ac_ext >&5
    5305 
    5306   ac_header_preproc=no
    5307 fi
    5308 
    5309 rm -f conftest.err conftest.$ac_ext
    5310 { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
    5311 echo "${ECHO_T}$ac_header_preproc" >&6; }
    5312 
    5313 # So?  What about this header?
    5314 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
    5315   yes:no: )
    5316     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
    5317 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
    5318     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
    5319 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
    5320     ac_header_preproc=yes
    5321     ;;
    5322   no:yes:* )
    5323     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
    5324 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
    5325     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
    5326 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
    5327     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
    5328 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
    5329     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
    5330 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
    5331     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
    5332 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
    5333     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
    5334 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
    5335 
    5336     ;;
    5337 esac
    5338 { echo "$as_me:$LINENO: checking for $ac_header" >&5
    5339 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
    5340 if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
    5341   echo $ECHO_N "(cached) $ECHO_C" >&6
    5342 else
    5343   eval "$as_ac_Header=\$ac_header_preproc"
    53446943fi
    53456944ac_res=`eval echo '${'$as_ac_Header'}'`
    53466945               { echo "$as_me:$LINENO: result: $ac_res" >&5
    53476946echo "${ECHO_T}$ac_res" >&6; }
    5348 
    5349 fi
    53506947if test `eval echo '${'$as_ac_Header'}'` = yes; then
    53516948  cat >>confdefs.h <<_ACEOF
     
    53576954done
    53586955
    5359 ac_ext=cpp
    5360 ac_cpp='$CXXCPP $CPPFLAGS'
    5361 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    5362 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    5363 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    5364 if test -z "$CXX"; then
    5365   if test -n "$CCC"; then
    5366     CXX=$CCC
    5367   else
    5368     if test -n "$ac_tool_prefix"; then
    5369   for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
    5370   do
    5371     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    5372 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    5373 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    5374 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    5375 if test "${ac_cv_prog_CXX+set}" = set; then
    5376   echo $ECHO_N "(cached) $ECHO_C" >&6
    5377 else
    5378   if test -n "$CXX"; then
    5379   ac_cv_prog_CXX="$CXX" # Let the user override the test.
    5380 else
    5381 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5382 for as_dir in $PATH
    5383 do
    5384   IFS=$as_save_IFS
    5385   test -z "$as_dir" && as_dir=.
    5386   for ac_exec_ext in '' $ac_executable_extensions; do
    5387   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    5388     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
    5389     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    5390     break 2
    5391   fi
    5392 done
    5393 done
    5394 IFS=$as_save_IFS
    5395 
    5396 fi
    5397 fi
    5398 CXX=$ac_cv_prog_CXX
    5399 if test -n "$CXX"; then
    5400   { echo "$as_me:$LINENO: result: $CXX" >&5
    5401 echo "${ECHO_T}$CXX" >&6; }
    5402 else
    5403   { echo "$as_me:$LINENO: result: no" >&5
    5404 echo "${ECHO_T}no" >&6; }
    5405 fi
    5406 
    5407 
    5408     test -n "$CXX" && break
    5409   done
    5410 fi
    5411 if test -z "$CXX"; then
    5412   ac_ct_CXX=$CXX
    5413   for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
    5414 do
    5415   # Extract the first word of "$ac_prog", so it can be a program name with args.
    5416 set dummy $ac_prog; ac_word=$2
    5417 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    5418 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    5419 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
    5420   echo $ECHO_N "(cached) $ECHO_C" >&6
    5421 else
    5422   if test -n "$ac_ct_CXX"; then
    5423   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
    5424 else
    5425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    5426 for as_dir in $PATH
    5427 do
    5428   IFS=$as_save_IFS
    5429   test -z "$as_dir" && as_dir=.
    5430   for ac_exec_ext in '' $ac_executable_extensions; do
    5431   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    5432     ac_cv_prog_ac_ct_CXX="$ac_prog"
    5433     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    5434     break 2
    5435   fi
    5436 done
    5437 done
    5438 IFS=$as_save_IFS
    5439 
    5440 fi
    5441 fi
    5442 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
    5443 if test -n "$ac_ct_CXX"; then
    5444   { echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
    5445 echo "${ECHO_T}$ac_ct_CXX" >&6; }
    5446 else
    5447   { echo "$as_me:$LINENO: result: no" >&5
    5448 echo "${ECHO_T}no" >&6; }
    5449 fi
    5450 
    5451 
    5452   test -n "$ac_ct_CXX" && break
    5453 done
    5454 
    5455   if test "x$ac_ct_CXX" = x; then
    5456     CXX="g++"
    5457   else
    5458     case $cross_compiling:$ac_tool_warned in
    5459 yes:)
    5460 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    5461 whose name does not start with the host triplet.  If you think this
    5462 configuration is useful to you, please write to autoconf@gnu.org." >&5
    5463 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    5464 whose name does not start with the host triplet.  If you think this
    5465 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    5466 ac_tool_warned=yes ;;
    5467 esac
    5468     CXX=$ac_ct_CXX
    5469   fi
    5470 fi
    5471 
    5472   fi
    5473 fi
    5474 # Provide some information about the compiler.
    5475 echo "$as_me:$LINENO: checking for C++ compiler version" >&5
    5476 ac_compiler=`set X $ac_compile; echo $2`
    5477 { (ac_try="$ac_compiler --version >&5"
    5478 case "(($ac_try" in
    5479   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5480   *) ac_try_echo=$ac_try;;
    5481 esac
    5482 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5483   (eval "$ac_compiler --version >&5") 2>&5
    5484   ac_status=$?
    5485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5486   (exit $ac_status); }
    5487 { (ac_try="$ac_compiler -v >&5"
    5488 case "(($ac_try" in
    5489   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5490   *) ac_try_echo=$ac_try;;
    5491 esac
    5492 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5493   (eval "$ac_compiler -v >&5") 2>&5
    5494   ac_status=$?
    5495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5496   (exit $ac_status); }
    5497 { (ac_try="$ac_compiler -V >&5"
    5498 case "(($ac_try" in
    5499   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5500   *) ac_try_echo=$ac_try;;
    5501 esac
    5502 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5503   (eval "$ac_compiler -V >&5") 2>&5
    5504   ac_status=$?
    5505   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5506   (exit $ac_status); }
    5507 
    5508 { echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
    5509 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6; }
    5510 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
    5511   echo $ECHO_N "(cached) $ECHO_C" >&6
    5512 else
    5513   cat >conftest.$ac_ext <<_ACEOF
    5514 /* confdefs.h.  */
    5515 _ACEOF
    5516 cat confdefs.h >>conftest.$ac_ext
    5517 cat >>conftest.$ac_ext <<_ACEOF
    5518 /* end confdefs.h.  */
    5519 
    5520 int
    5521 main ()
    5522 {
    5523 #ifndef __GNUC__
    5524        choke me
    5525 #endif
    5526 
    5527   ;
    5528   return 0;
    5529 }
    5530 _ACEOF
    5531 rm -f conftest.$ac_objext
    5532 if { (ac_try="$ac_compile"
    5533 case "(($ac_try" in
    5534   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5535   *) ac_try_echo=$ac_try;;
    5536 esac
    5537 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5538   (eval "$ac_compile") 2>conftest.er1
    5539   ac_status=$?
    5540   grep -v '^ *+' conftest.er1 >conftest.err
    5541   rm -f conftest.er1
    5542   cat conftest.err >&5
    5543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5544   (exit $ac_status); } && {
    5545          test -z "$ac_cxx_werror_flag" ||
    5546          test ! -s conftest.err
    5547        } && test -s conftest.$ac_objext; then
    5548   ac_compiler_gnu=yes
    5549 else
    5550   echo "$as_me: failed program was:" >&5
    5551 sed 's/^/| /' conftest.$ac_ext >&5
    5552 
    5553         ac_compiler_gnu=no
    5554 fi
    5555 
    5556 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5557 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
    5558 
    5559 fi
    5560 { echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
    5561 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6; }
    5562 GXX=`test $ac_compiler_gnu = yes && echo yes`
    5563 ac_test_CXXFLAGS=${CXXFLAGS+set}
    5564 ac_save_CXXFLAGS=$CXXFLAGS
    5565 { echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
    5566 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6; }
    5567 if test "${ac_cv_prog_cxx_g+set}" = set; then
    5568   echo $ECHO_N "(cached) $ECHO_C" >&6
    5569 else
    5570   ac_save_cxx_werror_flag=$ac_cxx_werror_flag
    5571    ac_cxx_werror_flag=yes
    5572    ac_cv_prog_cxx_g=no
    5573    CXXFLAGS="-g"
    5574    cat >conftest.$ac_ext <<_ACEOF
    5575 /* confdefs.h.  */
    5576 _ACEOF
    5577 cat confdefs.h >>conftest.$ac_ext
    5578 cat >>conftest.$ac_ext <<_ACEOF
    5579 /* end confdefs.h.  */
    5580 
    5581 int
    5582 main ()
    5583 {
    5584 
    5585   ;
    5586   return 0;
    5587 }
    5588 _ACEOF
    5589 rm -f conftest.$ac_objext
    5590 if { (ac_try="$ac_compile"
    5591 case "(($ac_try" in
    5592   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5593   *) ac_try_echo=$ac_try;;
    5594 esac
    5595 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5596   (eval "$ac_compile") 2>conftest.er1
    5597   ac_status=$?
    5598   grep -v '^ *+' conftest.er1 >conftest.err
    5599   rm -f conftest.er1
    5600   cat conftest.err >&5
    5601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5602   (exit $ac_status); } && {
    5603          test -z "$ac_cxx_werror_flag" ||
    5604          test ! -s conftest.err
    5605        } && test -s conftest.$ac_objext; then
    5606   ac_cv_prog_cxx_g=yes
    5607 else
    5608   echo "$as_me: failed program was:" >&5
    5609 sed 's/^/| /' conftest.$ac_ext >&5
    5610 
    5611         CXXFLAGS=""
    5612       cat >conftest.$ac_ext <<_ACEOF
    5613 /* confdefs.h.  */
    5614 _ACEOF
    5615 cat confdefs.h >>conftest.$ac_ext
    5616 cat >>conftest.$ac_ext <<_ACEOF
    5617 /* end confdefs.h.  */
    5618 
    5619 int
    5620 main ()
    5621 {
    5622 
    5623   ;
    5624   return 0;
    5625 }
    5626 _ACEOF
    5627 rm -f conftest.$ac_objext
    5628 if { (ac_try="$ac_compile"
    5629 case "(($ac_try" in
    5630   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5631   *) ac_try_echo=$ac_try;;
    5632 esac
    5633 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5634   (eval "$ac_compile") 2>conftest.er1
    5635   ac_status=$?
    5636   grep -v '^ *+' conftest.er1 >conftest.err
    5637   rm -f conftest.er1
    5638   cat conftest.err >&5
    5639   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5640   (exit $ac_status); } && {
    5641          test -z "$ac_cxx_werror_flag" ||
    5642          test ! -s conftest.err
    5643        } && test -s conftest.$ac_objext; then
    5644   :
    5645 else
    5646   echo "$as_me: failed program was:" >&5
    5647 sed 's/^/| /' conftest.$ac_ext >&5
    5648 
    5649         ac_cxx_werror_flag=$ac_save_cxx_werror_flag
    5650          CXXFLAGS="-g"
    5651          cat >conftest.$ac_ext <<_ACEOF
    5652 /* confdefs.h.  */
    5653 _ACEOF
    5654 cat confdefs.h >>conftest.$ac_ext
    5655 cat >>conftest.$ac_ext <<_ACEOF
    5656 /* end confdefs.h.  */
    5657 
    5658 int
    5659 main ()
    5660 {
    5661 
    5662   ;
    5663   return 0;
    5664 }
    5665 _ACEOF
    5666 rm -f conftest.$ac_objext
    5667 if { (ac_try="$ac_compile"
    5668 case "(($ac_try" in
    5669   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5670   *) ac_try_echo=$ac_try;;
    5671 esac
    5672 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5673   (eval "$ac_compile") 2>conftest.er1
    5674   ac_status=$?
    5675   grep -v '^ *+' conftest.er1 >conftest.err
    5676   rm -f conftest.er1
    5677   cat conftest.err >&5
    5678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5679   (exit $ac_status); } && {
    5680          test -z "$ac_cxx_werror_flag" ||
    5681          test ! -s conftest.err
    5682        } && test -s conftest.$ac_objext; then
    5683   ac_cv_prog_cxx_g=yes
    5684 else
    5685   echo "$as_me: failed program was:" >&5
    5686 sed 's/^/| /' conftest.$ac_ext >&5
    5687 
    5688 
    5689 fi
    5690 
    5691 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5692 fi
    5693 
    5694 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5695 fi
    5696 
    5697 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    5698    ac_cxx_werror_flag=$ac_save_cxx_werror_flag
    5699 fi
    5700 { echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
    5701 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6; }
    5702 if test "$ac_test_CXXFLAGS" = set; then
    5703   CXXFLAGS=$ac_save_CXXFLAGS
    5704 elif test $ac_cv_prog_cxx_g = yes; then
    5705   if test "$GXX" = yes; then
    5706     CXXFLAGS="-g -O2"
    5707   else
    5708     CXXFLAGS="-g"
    5709   fi
    5710 else
    5711   if test "$GXX" = yes; then
    5712     CXXFLAGS="-O2"
    5713   else
    5714     CXXFLAGS=
    5715   fi
    5716 fi
    5717 ac_ext=cpp
    5718 ac_cpp='$CXXCPP $CPPFLAGS'
    5719 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    5720 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    5721 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    5722 
    5723 depcc="$CXX"  am_compiler_list=
    5724 
    5725 { echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
    5726 echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; }
    5727 if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then
    5728   echo $ECHO_N "(cached) $ECHO_C" >&6
    5729 else
    5730   if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
    5731   # We make a subdir and do the tests there.  Otherwise we can end up
    5732   # making bogus files that we don't know about and never remove.  For
    5733   # instance it was reported that on HP-UX the gcc test will end up
    5734   # making a dummy file named `D' -- because `-MD' means `put the output
    5735   # in D'.
    5736   mkdir conftest.dir
    5737   # Copy depcomp to subdir because otherwise we won't find it if we're
    5738   # using a relative directory.
    5739   cp "$am_depcomp" conftest.dir
    5740   cd conftest.dir
    5741   # We will build objects and dependencies in a subdirectory because
    5742   # it helps to detect inapplicable dependency modes.  For instance
    5743   # both Tru64's cc and ICC support -MD to output dependencies as a
    5744   # side effect of compilation, but ICC will put the dependencies in
    5745   # the current directory while Tru64 will put them in the object
    5746   # directory.
    5747   mkdir sub
    5748 
    5749   am_cv_CXX_dependencies_compiler_type=none
    5750   if test "$am_compiler_list" = ""; then
    5751      am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
    5752   fi
    5753   for depmode in $am_compiler_list; do
    5754     # Setup a source with many dependencies, because some compilers
    5755     # like to wrap large dependency lists on column 80 (with \), and
    5756     # we should not choose a depcomp mode which is confused by this.
    5757     #
    5758     # We need to recreate these files for each test, as the compiler may
    5759     # overwrite some of them when testing with obscure command lines.
    5760     # This happens at least with the AIX C compiler.
    5761     : > sub/conftest.c
    5762     for i in 1 2 3 4 5 6; do
    5763       echo '#include "conftst'$i'.h"' >> sub/conftest.c
    5764       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
    5765       # Solaris 8's {/usr,}/bin/sh.
    5766       touch sub/conftst$i.h
    5767     done
    5768     echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    5769 
    5770     case $depmode in
    5771     nosideeffect)
    5772       # after this tag, mechanisms are not by side-effect, so they'll
    5773       # only be used when explicitly requested
    5774       if test "x$enable_dependency_tracking" = xyes; then
    5775         continue
    5776       else
    5777         break
    5778       fi
     6956
     6957
     6958# Set options
     6959
     6960
     6961
     6962        enable_dlopen=no
     6963
     6964
     6965  enable_win32_dll=no
     6966
     6967
     6968            # Check whether --enable-shared was given.
     6969if test "${enable_shared+set}" = set; then
     6970  enableval=$enable_shared; p=${PACKAGE-default}
     6971    case $enableval in
     6972    yes) enable_shared=yes ;;
     6973    no) enable_shared=no ;;
     6974    *)
     6975      enable_shared=no
     6976      # Look at the argument we got.  We use all the common list separators.
     6977      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
     6978      for pkg in $enableval; do
     6979        IFS="$lt_save_ifs"
     6980        if test "X$pkg" = "X$p"; then
     6981          enable_shared=yes
     6982        fi
     6983      done
     6984      IFS="$lt_save_ifs"
    57796985      ;;
    5780     none) break ;;
    57816986    esac
    5782     # We check with `-c' and `-o' for the sake of the "dashmstdout"
    5783     # mode.  It turns out that the SunPro C++ compiler does not properly
    5784     # handle `-M -o', and we need to detect this.
    5785     if depmode=$depmode \
    5786        source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
    5787        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
    5788        $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
    5789          >/dev/null 2>conftest.err &&
    5790        grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
    5791        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
    5792        grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
    5793        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
    5794       # icc doesn't choke on unknown options, it will just issue warnings
    5795       # or remarks (even with -Werror).  So we grep stderr for any message
    5796       # that says an option was ignored or not supported.
    5797       # When given -MP, icc 7.0 and 7.1 complain thusly:
    5798       #   icc: Command line warning: ignoring option '-M'; no argument required
    5799       # The diagnosis changed in icc 8.0:
    5800       #   icc: Command line remark: option '-MP' not supported
    5801       if (grep 'ignoring option' conftest.err ||
    5802           grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
    5803         am_cv_CXX_dependencies_compiler_type=$depmode
    5804         break
    5805       fi
    5806     fi
    5807   done
    5808 
    5809   cd ..
    5810   rm -rf conftest.dir
    5811 else
    5812   am_cv_CXX_dependencies_compiler_type=none
    5813 fi
    5814 
    5815 fi
    5816 { echo "$as_me:$LINENO: result: $am_cv_CXX_dependencies_compiler_type" >&5
    5817 echo "${ECHO_T}$am_cv_CXX_dependencies_compiler_type" >&6; }
    5818 CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
    5819 
    5820  if
    5821   test "x$enable_dependency_tracking" != xno \
    5822   && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
    5823   am__fastdepCXX_TRUE=
    5824   am__fastdepCXX_FALSE='#'
    5825 else
    5826   am__fastdepCXX_TRUE='#'
    5827   am__fastdepCXX_FALSE=
    5828 fi
    5829 
    5830 
    5831 
    5832 
    5833 if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
    5834     ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
    5835     (test "X$CXX" != "Xg++"))) ; then
    5836   ac_ext=cpp
    5837 ac_cpp='$CXXCPP $CPPFLAGS'
    5838 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    5839 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    5840 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    5841 { echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
    5842 echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6; }
    5843 if test -z "$CXXCPP"; then
    5844   if test "${ac_cv_prog_CXXCPP+set}" = set; then
    5845   echo $ECHO_N "(cached) $ECHO_C" >&6
    5846 else
    5847       # Double quotes because CXXCPP needs to be expanded
    5848     for CXXCPP in "$CXX -E" "/lib/cpp"
    5849     do
    5850       ac_preproc_ok=false
    5851 for ac_cxx_preproc_warn_flag in '' yes
    5852 do
    5853   # Use a header file that comes with gcc, so configuring glibc
    5854   # with a fresh cross-compiler works.
    5855   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    5856   # <limits.h> exists even on freestanding compilers.
    5857   # On the NeXT, cc -E runs the code through the compiler's parser,
    5858   # not just through cpp. "Syntax error" is here to catch this case.
    5859   cat >conftest.$ac_ext <<_ACEOF
    5860 /* confdefs.h.  */
    5861 _ACEOF
    5862 cat confdefs.h >>conftest.$ac_ext
    5863 cat >>conftest.$ac_ext <<_ACEOF
    5864 /* end confdefs.h.  */
    5865 #ifdef __STDC__
    5866 # include <limits.h>
    5867 #else
    5868 # include <assert.h>
    5869 #endif
    5870                      Syntax error
    5871 _ACEOF
    5872 if { (ac_try="$ac_cpp conftest.$ac_ext"
    5873 case "(($ac_try" in
    5874   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5875   *) ac_try_echo=$ac_try;;
    5876 esac
    5877 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5878   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    5879   ac_status=$?
    5880   grep -v '^ *+' conftest.er1 >conftest.err
    5881   rm -f conftest.er1
    5882   cat conftest.err >&5
    5883   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5884   (exit $ac_status); } >/dev/null && {
    5885          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    5886          test ! -s conftest.err
    5887        }; then
    5888   :
    5889 else
    5890   echo "$as_me: failed program was:" >&5
    5891 sed 's/^/| /' conftest.$ac_ext >&5
    5892 
    5893   # Broken: fails on valid input.
    5894 continue
    5895 fi
    5896 
    5897 rm -f conftest.err conftest.$ac_ext
    5898 
    5899   # OK, works on sane cases.  Now check whether nonexistent headers
    5900   # can be detected and how.
    5901   cat >conftest.$ac_ext <<_ACEOF
    5902 /* confdefs.h.  */
    5903 _ACEOF
    5904 cat confdefs.h >>conftest.$ac_ext
    5905 cat >>conftest.$ac_ext <<_ACEOF
    5906 /* end confdefs.h.  */
    5907 #include <ac_nonexistent.h>
    5908 _ACEOF
    5909 if { (ac_try="$ac_cpp conftest.$ac_ext"
    5910 case "(($ac_try" in
    5911   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5912   *) ac_try_echo=$ac_try;;
    5913 esac
    5914 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5915   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    5916   ac_status=$?
    5917   grep -v '^ *+' conftest.er1 >conftest.err
    5918   rm -f conftest.er1
    5919   cat conftest.err >&5
    5920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5921   (exit $ac_status); } >/dev/null && {
    5922          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    5923          test ! -s conftest.err
    5924        }; then
    5925   # Broken: success on invalid input.
    5926 continue
    5927 else
    5928   echo "$as_me: failed program was:" >&5
    5929 sed 's/^/| /' conftest.$ac_ext >&5
    5930 
    5931   # Passes both tests.
    5932 ac_preproc_ok=:
    5933 break
    5934 fi
    5935 
    5936 rm -f conftest.err conftest.$ac_ext
    5937 
    5938 done
    5939 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
    5940 rm -f conftest.err conftest.$ac_ext
    5941 if $ac_preproc_ok; then
    5942   break
    5943 fi
    5944 
    5945     done
    5946     ac_cv_prog_CXXCPP=$CXXCPP
    5947 
    5948 fi
    5949   CXXCPP=$ac_cv_prog_CXXCPP
    5950 else
    5951   ac_cv_prog_CXXCPP=$CXXCPP
    5952 fi
    5953 { echo "$as_me:$LINENO: result: $CXXCPP" >&5
    5954 echo "${ECHO_T}$CXXCPP" >&6; }
    5955 ac_preproc_ok=false
    5956 for ac_cxx_preproc_warn_flag in '' yes
    5957 do
    5958   # Use a header file that comes with gcc, so configuring glibc
    5959   # with a fresh cross-compiler works.
    5960   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
    5961   # <limits.h> exists even on freestanding compilers.
    5962   # On the NeXT, cc -E runs the code through the compiler's parser,
    5963   # not just through cpp. "Syntax error" is here to catch this case.
    5964   cat >conftest.$ac_ext <<_ACEOF
    5965 /* confdefs.h.  */
    5966 _ACEOF
    5967 cat confdefs.h >>conftest.$ac_ext
    5968 cat >>conftest.$ac_ext <<_ACEOF
    5969 /* end confdefs.h.  */
    5970 #ifdef __STDC__
    5971 # include <limits.h>
    5972 #else
    5973 # include <assert.h>
    5974 #endif
    5975                      Syntax error
    5976 _ACEOF
    5977 if { (ac_try="$ac_cpp conftest.$ac_ext"
    5978 case "(($ac_try" in
    5979   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    5980   *) ac_try_echo=$ac_try;;
    5981 esac
    5982 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    5983   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    5984   ac_status=$?
    5985   grep -v '^ *+' conftest.er1 >conftest.err
    5986   rm -f conftest.er1
    5987   cat conftest.err >&5
    5988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    5989   (exit $ac_status); } >/dev/null && {
    5990          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    5991          test ! -s conftest.err
    5992        }; then
    5993   :
    5994 else
    5995   echo "$as_me: failed program was:" >&5
    5996 sed 's/^/| /' conftest.$ac_ext >&5
    5997 
    5998   # Broken: fails on valid input.
    5999 continue
    6000 fi
    6001 
    6002 rm -f conftest.err conftest.$ac_ext
    6003 
    6004   # OK, works on sane cases.  Now check whether nonexistent headers
    6005   # can be detected and how.
    6006   cat >conftest.$ac_ext <<_ACEOF
    6007 /* confdefs.h.  */
    6008 _ACEOF
    6009 cat confdefs.h >>conftest.$ac_ext
    6010 cat >>conftest.$ac_ext <<_ACEOF
    6011 /* end confdefs.h.  */
    6012 #include <ac_nonexistent.h>
    6013 _ACEOF
    6014 if { (ac_try="$ac_cpp conftest.$ac_ext"
    6015 case "(($ac_try" in
    6016   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    6017   *) ac_try_echo=$ac_try;;
    6018 esac
    6019 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    6020   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
    6021   ac_status=$?
    6022   grep -v '^ *+' conftest.er1 >conftest.err
    6023   rm -f conftest.er1
    6024   cat conftest.err >&5
    6025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6026   (exit $ac_status); } >/dev/null && {
    6027          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
    6028          test ! -s conftest.err
    6029        }; then
    6030   # Broken: success on invalid input.
    6031 continue
    6032 else
    6033   echo "$as_me: failed program was:" >&5
    6034 sed 's/^/| /' conftest.$ac_ext >&5
    6035 
    6036   # Passes both tests.
    6037 ac_preproc_ok=:
    6038 break
    6039 fi
    6040 
    6041 rm -f conftest.err conftest.$ac_ext
    6042 
    6043 done
    6044 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
    6045 rm -f conftest.err conftest.$ac_ext
    6046 if $ac_preproc_ok; then
    6047   :
    6048 else
    6049   { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
    6050 See \`config.log' for more details." >&5
    6051 echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
    6052 See \`config.log' for more details." >&2;}
    6053    { (exit 1); exit 1; }; }
    6054 fi
    6055 
    6056 ac_ext=cpp
    6057 ac_cpp='$CXXCPP $CPPFLAGS'
    6058 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    6059 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    6060 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
    6061 
    6062 fi
    6063 
    6064 
    6065 ac_ext=f
    6066 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    6067 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    6068 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    6069 if test -n "$ac_tool_prefix"; then
    6070   for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
    6071   do
    6072     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    6073 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    6074 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6076 if test "${ac_cv_prog_F77+set}" = set; then
    6077   echo $ECHO_N "(cached) $ECHO_C" >&6
    6078 else
    6079   if test -n "$F77"; then
    6080   ac_cv_prog_F77="$F77" # Let the user override the test.
    6081 else
    6082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6083 for as_dir in $PATH
    6084 do
    6085   IFS=$as_save_IFS
    6086   test -z "$as_dir" && as_dir=.
    6087   for ac_exec_ext in '' $ac_executable_extensions; do
    6088   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6089     ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
    6090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6091     break 2
    6092   fi
    6093 done
    6094 done
    6095 IFS=$as_save_IFS
    6096 
    6097 fi
    6098 fi
    6099 F77=$ac_cv_prog_F77
    6100 if test -n "$F77"; then
    6101   { echo "$as_me:$LINENO: result: $F77" >&5
    6102 echo "${ECHO_T}$F77" >&6; }
    6103 else
    6104   { echo "$as_me:$LINENO: result: no" >&5
    6105 echo "${ECHO_T}no" >&6; }
    6106 fi
    6107 
    6108 
    6109     test -n "$F77" && break
    6110   done
    6111 fi
    6112 if test -z "$F77"; then
    6113   ac_ct_F77=$F77
    6114   for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
    6115 do
    6116   # Extract the first word of "$ac_prog", so it can be a program name with args.
    6117 set dummy $ac_prog; ac_word=$2
    6118 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6120 if test "${ac_cv_prog_ac_ct_F77+set}" = set; then
    6121   echo $ECHO_N "(cached) $ECHO_C" >&6
    6122 else
    6123   if test -n "$ac_ct_F77"; then
    6124   ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.
    6125 else
    6126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6127 for as_dir in $PATH
    6128 do
    6129   IFS=$as_save_IFS
    6130   test -z "$as_dir" && as_dir=.
    6131   for ac_exec_ext in '' $ac_executable_extensions; do
    6132   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6133     ac_cv_prog_ac_ct_F77="$ac_prog"
    6134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6135     break 2
    6136   fi
    6137 done
    6138 done
    6139 IFS=$as_save_IFS
    6140 
    6141 fi
    6142 fi
    6143 ac_ct_F77=$ac_cv_prog_ac_ct_F77
    6144 if test -n "$ac_ct_F77"; then
    6145   { echo "$as_me:$LINENO: result: $ac_ct_F77" >&5
    6146 echo "${ECHO_T}$ac_ct_F77" >&6; }
    6147 else
    6148   { echo "$as_me:$LINENO: result: no" >&5
    6149 echo "${ECHO_T}no" >&6; }
    6150 fi
    6151 
    6152 
    6153   test -n "$ac_ct_F77" && break
    6154 done
    6155 
    6156   if test "x$ac_ct_F77" = x; then
    6157     F77=""
    6158   else
    6159     case $cross_compiling:$ac_tool_warned in
    6160 yes:)
    6161 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    6162 whose name does not start with the host triplet.  If you think this
    6163 configuration is useful to you, please write to autoconf@gnu.org." >&5
    6164 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    6165 whose name does not start with the host triplet.  If you think this
    6166 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    6167 ac_tool_warned=yes ;;
    6168 esac
    6169     F77=$ac_ct_F77
    6170   fi
    6171 fi
    6172 
    6173 
    6174 # Provide some information about the compiler.
    6175 echo "$as_me:$LINENO: checking for Fortran 77 compiler version" >&5
    6176 ac_compiler=`set X $ac_compile; echo $2`
    6177 { (ac_try="$ac_compiler --version >&5"
    6178 case "(($ac_try" in
    6179   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    6180   *) ac_try_echo=$ac_try;;
    6181 esac
    6182 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    6183   (eval "$ac_compiler --version >&5") 2>&5
    6184   ac_status=$?
    6185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6186   (exit $ac_status); }
    6187 { (ac_try="$ac_compiler -v >&5"
    6188 case "(($ac_try" in
    6189   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    6190   *) ac_try_echo=$ac_try;;
    6191 esac
    6192 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    6193   (eval "$ac_compiler -v >&5") 2>&5
    6194   ac_status=$?
    6195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6196   (exit $ac_status); }
    6197 { (ac_try="$ac_compiler -V >&5"
    6198 case "(($ac_try" in
    6199   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    6200   *) ac_try_echo=$ac_try;;
    6201 esac
    6202 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    6203   (eval "$ac_compiler -V >&5") 2>&5
    6204   ac_status=$?
    6205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6206   (exit $ac_status); }
    6207 rm -f a.out
    6208 
    6209 # If we don't use `.F' as extension, the preprocessor is not run on the
    6210 # input file.  (Note that this only needs to work for GNU compilers.)
    6211 ac_save_ext=$ac_ext
    6212 ac_ext=F
    6213 { echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5
    6214 echo $ECHO_N "checking whether we are using the GNU Fortran 77 compiler... $ECHO_C" >&6; }
    6215 if test "${ac_cv_f77_compiler_gnu+set}" = set; then
    6216   echo $ECHO_N "(cached) $ECHO_C" >&6
    6217 else
    6218   cat >conftest.$ac_ext <<_ACEOF
    6219       program main
    6220 #ifndef __GNUC__
    6221        choke me
    6222 #endif
    6223 
    6224       end
    6225 _ACEOF
    6226 rm -f conftest.$ac_objext
    6227 if { (ac_try="$ac_compile"
    6228 case "(($ac_try" in
    6229   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    6230   *) ac_try_echo=$ac_try;;
    6231 esac
    6232 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    6233   (eval "$ac_compile") 2>conftest.er1
    6234   ac_status=$?
    6235   grep -v '^ *+' conftest.er1 >conftest.err
    6236   rm -f conftest.er1
    6237   cat conftest.err >&5
    6238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6239   (exit $ac_status); } && {
    6240          test -z "$ac_f77_werror_flag" ||
    6241          test ! -s conftest.err
    6242        } && test -s conftest.$ac_objext; then
    6243   ac_compiler_gnu=yes
    6244 else
    6245   echo "$as_me: failed program was:" >&5
    6246 sed 's/^/| /' conftest.$ac_ext >&5
    6247 
    6248         ac_compiler_gnu=no
    6249 fi
    6250 
    6251 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    6252 ac_cv_f77_compiler_gnu=$ac_compiler_gnu
    6253 
    6254 fi
    6255 { echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5
    6256 echo "${ECHO_T}$ac_cv_f77_compiler_gnu" >&6; }
    6257 ac_ext=$ac_save_ext
    6258 ac_test_FFLAGS=${FFLAGS+set}
    6259 ac_save_FFLAGS=$FFLAGS
    6260 FFLAGS=
    6261 { echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5
    6262 echo $ECHO_N "checking whether $F77 accepts -g... $ECHO_C" >&6; }
    6263 if test "${ac_cv_prog_f77_g+set}" = set; then
    6264   echo $ECHO_N "(cached) $ECHO_C" >&6
    6265 else
    6266   FFLAGS=-g
    6267 cat >conftest.$ac_ext <<_ACEOF
    6268       program main
    6269 
    6270       end
    6271 _ACEOF
    6272 rm -f conftest.$ac_objext
    6273 if { (ac_try="$ac_compile"
    6274 case "(($ac_try" in
    6275   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    6276   *) ac_try_echo=$ac_try;;
    6277 esac
    6278 eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
    6279   (eval "$ac_compile") 2>conftest.er1
    6280   ac_status=$?
    6281   grep -v '^ *+' conftest.er1 >conftest.err
    6282   rm -f conftest.er1
    6283   cat conftest.err >&5
    6284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6285   (exit $ac_status); } && {
    6286          test -z "$ac_f77_werror_flag" ||
    6287          test ! -s conftest.err
    6288        } && test -s conftest.$ac_objext; then
    6289   ac_cv_prog_f77_g=yes
    6290 else
    6291   echo "$as_me: failed program was:" >&5
    6292 sed 's/^/| /' conftest.$ac_ext >&5
    6293 
    6294         ac_cv_prog_f77_g=no
    6295 fi
    6296 
    6297 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    6298 
    6299 fi
    6300 { echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5
    6301 echo "${ECHO_T}$ac_cv_prog_f77_g" >&6; }
    6302 if test "$ac_test_FFLAGS" = set; then
    6303   FFLAGS=$ac_save_FFLAGS
    6304 elif test $ac_cv_prog_f77_g = yes; then
    6305   if test "x$ac_cv_f77_compiler_gnu" = xyes; then
    6306     FFLAGS="-g -O2"
    6307   else
    6308     FFLAGS="-g"
    6309   fi
    6310 else
    6311   if test "x$ac_cv_f77_compiler_gnu" = xyes; then
    6312     FFLAGS="-O2"
    6313   else
    6314     FFLAGS=
    6315   fi
    6316 fi
    6317 
    6318 G77=`test $ac_compiler_gnu = yes && echo yes`
    6319 ac_ext=c
    6320 ac_cpp='$CPP $CPPFLAGS'
    6321 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    6322 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    6323 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    6324 
    6325 
    6326 
    6327 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
    6328 # find the maximum length of command line arguments
    6329 { echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
    6330 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6; }
    6331 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
    6332   echo $ECHO_N "(cached) $ECHO_C" >&6
    6333 else
    6334     i=0
    6335   teststring="ABCD"
    6336 
    6337   case $build_os in
    6338   msdosdjgpp*)
    6339     # On DJGPP, this test can blow up pretty badly due to problems in libc
    6340     # (any single argument exceeding 2000 bytes causes a buffer overrun
    6341     # during glob expansion).  Even if it were fixed, the result of this
    6342     # check would be larger than it should be.
    6343     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
    6344     ;;
    6345 
    6346   gnu*)
    6347     # Under GNU Hurd, this test is not required because there is
    6348     # no limit to the length of command line arguments.
    6349     # Libtool will interpret -1 as no limit whatsoever
    6350     lt_cv_sys_max_cmd_len=-1;
    6351     ;;
    6352 
    6353   cygwin* | mingw*)
    6354     # On Win9x/ME, this test blows up -- it succeeds, but takes
    6355     # about 5 minutes as the teststring grows exponentially.
    6356     # Worse, since 9x/ME are not pre-emptively multitasking,
    6357     # you end up with a "frozen" computer, even though with patience
    6358     # the test eventually succeeds (with a max line length of 256k).
    6359     # Instead, let's just punt: use the minimum linelength reported by
    6360     # all of the supported platforms: 8192 (on NT/2K/XP).
    6361     lt_cv_sys_max_cmd_len=8192;
    6362     ;;
    6363 
    6364   amigaos*)
    6365     # On AmigaOS with pdksh, this test takes hours, literally.
    6366     # So we just punt and use a minimum line length of 8192.
    6367     lt_cv_sys_max_cmd_len=8192;
    6368     ;;
    6369 
    6370   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
    6371     # This has been around since 386BSD, at least.  Likely further.
    6372     if test -x /sbin/sysctl; then
    6373       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
    6374     elif test -x /usr/sbin/sysctl; then
    6375       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
    6376     else
    6377       lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
    6378     fi
    6379     # And add a safety zone
    6380     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
    6381     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    6382     ;;
    6383 
    6384   interix*)
    6385     # We know the value 262144 and hardcode it with a safety zone (like BSD)
    6386     lt_cv_sys_max_cmd_len=196608
    6387     ;;
    6388 
    6389   osf*)
    6390     # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
    6391     # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
    6392     # nice to cause kernel panics so lets avoid the loop below.
    6393     # First set a reasonable default.
    6394     lt_cv_sys_max_cmd_len=16384
    6395     #
    6396     if test -x /sbin/sysconfig; then
    6397       case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
    6398         *1*) lt_cv_sys_max_cmd_len=-1 ;;
    6399       esac
    6400     fi
    6401     ;;
    6402   sco3.2v5*)
    6403     lt_cv_sys_max_cmd_len=102400
    6404     ;;
    6405   sysv5* | sco5v6* | sysv4.2uw2*)
    6406     kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
    6407     if test -n "$kargmax"; then
    6408       lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[         ]//'`
    6409     else
    6410       lt_cv_sys_max_cmd_len=32768
    6411     fi
    6412     ;;
    6413   *)
    6414     lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
    6415     if test -n "$lt_cv_sys_max_cmd_len"; then
    6416       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
    6417       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    6418     else
    6419       SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
    6420       while (test "X"`$SHELL $0 --fallback-echo "X$teststring" 2>/dev/null` \
    6421                = "XX$teststring") >/dev/null 2>&1 &&
    6422               new_result=`expr "X$teststring" : ".*" 2>&1` &&
    6423               lt_cv_sys_max_cmd_len=$new_result &&
    6424               test $i != 17 # 1/2 MB should be enough
    6425       do
    6426         i=`expr $i + 1`
    6427         teststring=$teststring$teststring
     6987else
     6988  enable_shared=yes
     6989fi
     6990
     6991
     6992
     6993
     6994
     6995
     6996
     6997
     6998
     6999  # Check whether --enable-static was given.
     7000if test "${enable_static+set}" = set; then
     7001  enableval=$enable_static; p=${PACKAGE-default}
     7002    case $enableval in
     7003    yes) enable_static=yes ;;
     7004    no) enable_static=no ;;
     7005    *)
     7006     enable_static=no
     7007      # Look at the argument we got.  We use all the common list separators.
     7008      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
     7009      for pkg in $enableval; do
     7010        IFS="$lt_save_ifs"
     7011        if test "X$pkg" = "X$p"; then
     7012          enable_static=yes
     7013        fi
    64287014      done
    6429       teststring=
    6430       # Add a significant safety factor because C++ compilers can tack on massive
    6431       # amounts of additional arguments before passing them to the linker.
    6432       # It appears as though 1/2 is a usable value.
    6433       lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
    6434     fi
    6435     ;;
    6436   esac
    6437 
    6438 fi
    6439 
    6440 if test -n $lt_cv_sys_max_cmd_len ; then
    6441   { echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
    6442 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6; }
    6443 else
    6444   { echo "$as_me:$LINENO: result: none" >&5
    6445 echo "${ECHO_T}none" >&6; }
    6446 fi
    6447 
    6448 
    6449 
    6450 
    6451 
    6452 # Check for command to grab the raw symbol name followed by C symbol from nm.
    6453 { echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5
    6454 echo $ECHO_N "checking command to parse $NM output from $compiler object... $ECHO_C" >&6; }
    6455 if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
    6456   echo $ECHO_N "(cached) $ECHO_C" >&6
    6457 else
    6458 
    6459 # These are sane defaults that work on at least a few old systems.
    6460 # [They come from Ultrix.  What could be older than Ultrix?!! ;)]
    6461 
    6462 # Character class describing NM global symbol codes.
    6463 symcode='[BCDEGRST]'
    6464 
    6465 # Regexp to match symbols that can be accessed directly from C.
    6466 sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
    6467 
    6468 # Transform an extracted symbol line into a proper C declaration
    6469 lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
    6470 
    6471 # Transform an extracted symbol line into symbol name and symbol address
    6472 lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
    6473 
    6474 # Define system-specific variables.
    6475 case $host_os in
    6476 aix*)
    6477   symcode='[BCDT]'
    6478   ;;
    6479 cygwin* | mingw* | pw32*)
    6480   symcode='[ABCDGISTW]'
    6481   ;;
    6482 hpux*) # Its linker distinguishes data from code symbols
    6483   if test "$host_cpu" = ia64; then
    6484     symcode='[ABCDEGRST]'
    6485   fi
    6486   lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
    6487   lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
    6488   ;;
    6489 linux* | k*bsd*-gnu)
    6490   if test "$host_cpu" = ia64; then
    6491     symcode='[ABCDGIRSTW]'
    6492     lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
    6493     lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
    6494   fi
    6495   ;;
    6496 irix* | nonstopux*)
    6497   symcode='[BCDEGRST]'
    6498   ;;
    6499 osf*)
    6500   symcode='[BCDEGQRST]'
    6501   ;;
    6502 solaris*)
    6503   symcode='[BDRT]'
    6504   ;;
    6505 sco3.2v5*)
    6506   symcode='[DT]'
    6507   ;;
    6508 sysv4.2uw2*)
    6509   symcode='[DT]'
    6510   ;;
    6511 sysv5* | sco5v6* | unixware* | OpenUNIX*)
    6512   symcode='[ABDT]'
    6513   ;;
    6514 sysv4)
    6515   symcode='[DFNSTU]'
    6516   ;;
    6517 esac
    6518 
    6519 # Handle CRLF in mingw tool chain
    6520 opt_cr=
    6521 case $build_os in
    6522 mingw*)
    6523   opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
    6524   ;;
    6525 esac
    6526 
    6527 # If we're using GNU nm, then use its standard symbol codes.
    6528 case `$NM -V 2>&1` in
    6529 *GNU* | *'with BFD'*)
    6530   symcode='[ABCDGIRSTW]' ;;
    6531 esac
    6532 
    6533 # Try without a prefix undercore, then with it.
    6534 for ac_symprfx in "" "_"; do
    6535 
    6536   # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
    6537   symxfrm="\\1 $ac_symprfx\\2 \\2"
    6538 
    6539   # Write the raw and C identifiers.
    6540   lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[       ]\($symcode$symcode*\)[         ][      ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
    6541 
    6542   # Check to see that the pipe works correctly.
    6543   pipe_works=no
    6544 
    6545   rm -f conftest*
    6546   cat > conftest.$ac_ext <<EOF
    6547 #ifdef __cplusplus
    6548 extern "C" {
    6549 #endif
    6550 char nm_test_var;
    6551 void nm_test_func(){}
    6552 #ifdef __cplusplus
    6553 }
    6554 #endif
    6555 int main(){nm_test_var='a';nm_test_func();return(0);}
    6556 EOF
    6557 
    6558   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
    6559   (eval $ac_compile) 2>&5
    6560   ac_status=$?
    6561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6562   (exit $ac_status); }; then
    6563     # Now try to grab the symbols.
    6564     nlist=conftest.nm
    6565     if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
    6566   (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
    6567   ac_status=$?
    6568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6569   (exit $ac_status); } && test -s "$nlist"; then
    6570       # Try sorting and uniquifying the output.
    6571       if sort "$nlist" | uniq > "$nlist"T; then
    6572         mv -f "$nlist"T "$nlist"
    6573       else
    6574         rm -f "$nlist"T
    6575       fi
    6576 
    6577       # Make sure that we snagged all the symbols we need.
    6578       if grep ' nm_test_var$' "$nlist" >/dev/null; then
    6579         if grep ' nm_test_func$' "$nlist" >/dev/null; then
    6580           cat <<EOF > conftest.$ac_ext
    6581 #ifdef __cplusplus
    6582 extern "C" {
    6583 #endif
    6584 
    6585 EOF
    6586           # Now generate the symbol file.
    6587           eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'
    6588 
    6589           cat <<EOF >> conftest.$ac_ext
    6590 #if defined (__STDC__) && __STDC__
    6591 # define lt_ptr_t void *
    6592 #else
    6593 # define lt_ptr_t char *
    6594 # define const
    6595 #endif
    6596 
    6597 /* The mapping between symbol names and symbols. */
    6598 const struct {
    6599   const char *name;
    6600   lt_ptr_t address;
    6601 }
    6602 lt_preloaded_symbols[] =
    6603 {
    6604 EOF
    6605           $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext
    6606           cat <<\EOF >> conftest.$ac_ext
    6607   {0, (lt_ptr_t) 0}
    6608 };
    6609 
    6610 #ifdef __cplusplus
    6611 }
    6612 #endif
    6613 EOF
    6614           # Now try linking the two files.
    6615           mv conftest.$ac_objext conftstm.$ac_objext
    6616           lt_save_LIBS="$LIBS"
    6617           lt_save_CFLAGS="$CFLAGS"
    6618           LIBS="conftstm.$ac_objext"
    6619           CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
    6620           if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
    6621   (eval $ac_link) 2>&5
    6622   ac_status=$?
    6623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
    6624   (exit $ac_status); } && test -s conftest${ac_exeext}; then
    6625             pipe_works=yes
    6626           fi
    6627           LIBS="$lt_save_LIBS"
    6628           CFLAGS="$lt_save_CFLAGS"
    6629         else
    6630           echo "cannot find nm_test_func in $nlist" >&5
     7015      IFS="$lt_save_ifs"
     7016      ;;
     7017    esac
     7018else
     7019  enable_static=yes
     7020fi
     7021
     7022
     7023
     7024
     7025
     7026
     7027
     7028
     7029
     7030
     7031# Check whether --with-pic was given.
     7032if test "${with_pic+set}" = set; then
     7033  withval=$with_pic; pic_mode="$withval"
     7034else
     7035  pic_mode=default
     7036fi
     7037
     7038
     7039test -z "$pic_mode" && pic_mode=default
     7040
     7041
     7042
     7043
     7044
     7045
     7046
     7047  # Check whether --enable-fast-install was given.
     7048if test "${enable_fast_install+set}" = set; then
     7049  enableval=$enable_fast_install; p=${PACKAGE-default}
     7050    case $enableval in
     7051    yes) enable_fast_install=yes ;;
     7052    no) enable_fast_install=no ;;
     7053    *)
     7054      enable_fast_install=no
     7055      # Look at the argument we got.  We use all the common list separators.
     7056      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
     7057      for pkg in $enableval; do
     7058        IFS="$lt_save_ifs"
     7059        if test "X$pkg" = "X$p"; then
     7060          enable_fast_install=yes
    66317061        fi
    6632       else
    6633         echo "cannot find nm_test_var in $nlist" >&5
    6634       fi
    6635     else
    6636       echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
    6637     fi
    6638   else
    6639     echo "$progname: failed program was:" >&5
    6640     cat conftest.$ac_ext >&5
    6641   fi
    6642   rm -rf conftest* conftst*
    6643 
    6644   # Do not use the global_symbol_pipe unless it works.
    6645   if test "$pipe_works" = yes; then
    6646     break
    6647   else
    6648     lt_cv_sys_global_symbol_pipe=
    6649   fi
    6650 done
    6651 
    6652 fi
    6653 
    6654 if test -z "$lt_cv_sys_global_symbol_pipe"; then
    6655   lt_cv_sys_global_symbol_to_cdecl=
    6656 fi
    6657 if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
    6658   { echo "$as_me:$LINENO: result: failed" >&5
    6659 echo "${ECHO_T}failed" >&6; }
    6660 else
    6661   { echo "$as_me:$LINENO: result: ok" >&5
    6662 echo "${ECHO_T}ok" >&6; }
     7062      done
     7063      IFS="$lt_save_ifs"
     7064      ;;
     7065    esac
     7066else
     7067  enable_fast_install=yes
     7068fi
     7069
     7070
     7071
     7072
     7073
     7074
     7075
     7076
     7077
     7078
     7079
     7080# This can be used to rebuild libtool when needed
     7081LIBTOOL_DEPS="$ltmain"
     7082
     7083# Always use our own libtool.
     7084LIBTOOL='$(SHELL) $(top_builddir)/libtool'
     7085
     7086
     7087
     7088
     7089
     7090
     7091
     7092
     7093
     7094
     7095
     7096
     7097
     7098
     7099
     7100
     7101
     7102
     7103
     7104
     7105
     7106
     7107
     7108
     7109
     7110test -z "$LN_S" && LN_S="ln -s"
     7111
     7112
     7113
     7114
     7115
     7116
     7117
     7118
     7119
     7120
     7121
     7122
     7123
     7124
     7125if test -n "${ZSH_VERSION+set}" ; then
     7126   setopt NO_GLOB_SUBST
    66637127fi
    66647128
     
    66817145echo "${ECHO_T}$lt_cv_objdir" >&6; }
    66827146objdir=$lt_cv_objdir
     7147
     7148
     7149
     7150
     7151
     7152cat >>confdefs.h <<_ACEOF
     7153#define LT_OBJDIR "$lt_cv_objdir/"
     7154_ACEOF
     7155
     7156
     7157
     7158
     7159
     7160
     7161
     7162
     7163
     7164
     7165
     7166
    66837167
    66847168
     
    67007184# Sed substitution that helps us do robust quoting.  It backslashifies
    67017185# metacharacters that are still active within double-quoted strings.
    6702 Xsed='sed -e 1s/^X//'
    6703 sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g'
     7186sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
    67047187
    67057188# Same as above, but do not quote variable references.
    6706 double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g'
     7189double_quote_subst='s/\(["`\\]\)/\\\1/g'
    67077190
    67087191# Sed substitution to delay expansion of an escaped shell variable in a
     
    67107193delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
    67117194
     7195# Sed substitution to delay expansion of an escaped single quote.
     7196delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
     7197
    67127198# Sed substitution to avoid accidental globbing in evaled expressions
    67137199no_glob_subst='s/\*/\\\*/g'
    67147200
    6715 # Constants:
    6716 rm="rm -f"
    6717 
    67187201# Global variables:
    6719 default_ofile=libtool
     7202ofile=libtool
    67207203can_build_shared=yes
    67217204
     
    67237206# which needs '.lib').
    67247207libext=a
    6725 ltmain="$ac_aux_dir/ltmain.sh"
    6726 ofile="$default_ofile"
     7208
    67277209with_gnu_ld="$lt_cv_prog_gnu_ld"
    6728 
    6729 if test -n "$ac_tool_prefix"; then
    6730   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
    6731 set dummy ${ac_tool_prefix}ar; ac_word=$2
    6732 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6734 if test "${ac_cv_prog_AR+set}" = set; then
    6735   echo $ECHO_N "(cached) $ECHO_C" >&6
    6736 else
    6737   if test -n "$AR"; then
    6738   ac_cv_prog_AR="$AR" # Let the user override the test.
    6739 else
    6740 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6741 for as_dir in $PATH
    6742 do
    6743   IFS=$as_save_IFS
    6744   test -z "$as_dir" && as_dir=.
    6745   for ac_exec_ext in '' $ac_executable_extensions; do
    6746   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6747     ac_cv_prog_AR="${ac_tool_prefix}ar"
    6748     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6749     break 2
    6750   fi
    6751 done
    6752 done
    6753 IFS=$as_save_IFS
    6754 
    6755 fi
    6756 fi
    6757 AR=$ac_cv_prog_AR
    6758 if test -n "$AR"; then
    6759   { echo "$as_me:$LINENO: result: $AR" >&5
    6760 echo "${ECHO_T}$AR" >&6; }
    6761 else
    6762   { echo "$as_me:$LINENO: result: no" >&5
    6763 echo "${ECHO_T}no" >&6; }
    6764 fi
    6765 
    6766 
    6767 fi
    6768 if test -z "$ac_cv_prog_AR"; then
    6769   ac_ct_AR=$AR
    6770   # Extract the first word of "ar", so it can be a program name with args.
    6771 set dummy ar; ac_word=$2
    6772 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6773 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6774 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
    6775   echo $ECHO_N "(cached) $ECHO_C" >&6
    6776 else
    6777   if test -n "$ac_ct_AR"; then
    6778   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
    6779 else
    6780 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6781 for as_dir in $PATH
    6782 do
    6783   IFS=$as_save_IFS
    6784   test -z "$as_dir" && as_dir=.
    6785   for ac_exec_ext in '' $ac_executable_extensions; do
    6786   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6787     ac_cv_prog_ac_ct_AR="ar"
    6788     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6789     break 2
    6790   fi
    6791 done
    6792 done
    6793 IFS=$as_save_IFS
    6794 
    6795 fi
    6796 fi
    6797 ac_ct_AR=$ac_cv_prog_ac_ct_AR
    6798 if test -n "$ac_ct_AR"; then
    6799   { echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
    6800 echo "${ECHO_T}$ac_ct_AR" >&6; }
    6801 else
    6802   { echo "$as_me:$LINENO: result: no" >&5
    6803 echo "${ECHO_T}no" >&6; }
    6804 fi
    6805 
    6806   if test "x$ac_ct_AR" = x; then
    6807     AR="false"
    6808   else
    6809     case $cross_compiling:$ac_tool_warned in
    6810 yes:)
    6811 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    6812 whose name does not start with the host triplet.  If you think this
    6813 configuration is useful to you, please write to autoconf@gnu.org." >&5
    6814 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    6815 whose name does not start with the host triplet.  If you think this
    6816 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    6817 ac_tool_warned=yes ;;
    6818 esac
    6819     AR=$ac_ct_AR
    6820   fi
    6821 else
    6822   AR="$ac_cv_prog_AR"
    6823 fi
    6824 
    6825 if test -n "$ac_tool_prefix"; then
    6826   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
    6827 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
    6828 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6830 if test "${ac_cv_prog_RANLIB+set}" = set; then
    6831   echo $ECHO_N "(cached) $ECHO_C" >&6
    6832 else
    6833   if test -n "$RANLIB"; then
    6834   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
    6835 else
    6836 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6837 for as_dir in $PATH
    6838 do
    6839   IFS=$as_save_IFS
    6840   test -z "$as_dir" && as_dir=.
    6841   for ac_exec_ext in '' $ac_executable_extensions; do
    6842   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6843     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
    6844     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6845     break 2
    6846   fi
    6847 done
    6848 done
    6849 IFS=$as_save_IFS
    6850 
    6851 fi
    6852 fi
    6853 RANLIB=$ac_cv_prog_RANLIB
    6854 if test -n "$RANLIB"; then
    6855   { echo "$as_me:$LINENO: result: $RANLIB" >&5
    6856 echo "${ECHO_T}$RANLIB" >&6; }
    6857 else
    6858   { echo "$as_me:$LINENO: result: no" >&5
    6859 echo "${ECHO_T}no" >&6; }
    6860 fi
    6861 
    6862 
    6863 fi
    6864 if test -z "$ac_cv_prog_RANLIB"; then
    6865   ac_ct_RANLIB=$RANLIB
    6866   # Extract the first word of "ranlib", so it can be a program name with args.
    6867 set dummy ranlib; ac_word=$2
    6868 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6869 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6870 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
    6871   echo $ECHO_N "(cached) $ECHO_C" >&6
    6872 else
    6873   if test -n "$ac_ct_RANLIB"; then
    6874   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
    6875 else
    6876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6877 for as_dir in $PATH
    6878 do
    6879   IFS=$as_save_IFS
    6880   test -z "$as_dir" && as_dir=.
    6881   for ac_exec_ext in '' $ac_executable_extensions; do
    6882   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6883     ac_cv_prog_ac_ct_RANLIB="ranlib"
    6884     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6885     break 2
    6886   fi
    6887 done
    6888 done
    6889 IFS=$as_save_IFS
    6890 
    6891 fi
    6892 fi
    6893 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
    6894 if test -n "$ac_ct_RANLIB"; then
    6895   { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
    6896 echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
    6897 else
    6898   { echo "$as_me:$LINENO: result: no" >&5
    6899 echo "${ECHO_T}no" >&6; }
    6900 fi
    6901 
    6902   if test "x$ac_ct_RANLIB" = x; then
    6903     RANLIB=":"
    6904   else
    6905     case $cross_compiling:$ac_tool_warned in
    6906 yes:)
    6907 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    6908 whose name does not start with the host triplet.  If you think this
    6909 configuration is useful to you, please write to autoconf@gnu.org." >&5
    6910 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    6911 whose name does not start with the host triplet.  If you think this
    6912 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    6913 ac_tool_warned=yes ;;
    6914 esac
    6915     RANLIB=$ac_ct_RANLIB
    6916   fi
    6917 else
    6918   RANLIB="$ac_cv_prog_RANLIB"
    6919 fi
    6920 
    6921 if test -n "$ac_tool_prefix"; then
    6922   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
    6923 set dummy ${ac_tool_prefix}strip; ac_word=$2
    6924 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6926 if test "${ac_cv_prog_STRIP+set}" = set; then
    6927   echo $ECHO_N "(cached) $ECHO_C" >&6
    6928 else
    6929   if test -n "$STRIP"; then
    6930   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
    6931 else
    6932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6933 for as_dir in $PATH
    6934 do
    6935   IFS=$as_save_IFS
    6936   test -z "$as_dir" && as_dir=.
    6937   for ac_exec_ext in '' $ac_executable_extensions; do
    6938   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6939     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
    6940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6941     break 2
    6942   fi
    6943 done
    6944 done
    6945 IFS=$as_save_IFS
    6946 
    6947 fi
    6948 fi
    6949 STRIP=$ac_cv_prog_STRIP
    6950 if test -n "$STRIP"; then
    6951   { echo "$as_me:$LINENO: result: $STRIP" >&5
    6952 echo "${ECHO_T}$STRIP" >&6; }
    6953 else
    6954   { echo "$as_me:$LINENO: result: no" >&5
    6955 echo "${ECHO_T}no" >&6; }
    6956 fi
    6957 
    6958 
    6959 fi
    6960 if test -z "$ac_cv_prog_STRIP"; then
    6961   ac_ct_STRIP=$STRIP
    6962   # Extract the first word of "strip", so it can be a program name with args.
    6963 set dummy strip; ac_word=$2
    6964 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    6965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    6966 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
    6967   echo $ECHO_N "(cached) $ECHO_C" >&6
    6968 else
    6969   if test -n "$ac_ct_STRIP"; then
    6970   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
    6971 else
    6972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    6973 for as_dir in $PATH
    6974 do
    6975   IFS=$as_save_IFS
    6976   test -z "$as_dir" && as_dir=.
    6977   for ac_exec_ext in '' $ac_executable_extensions; do
    6978   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    6979     ac_cv_prog_ac_ct_STRIP="strip"
    6980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    6981     break 2
    6982   fi
    6983 done
    6984 done
    6985 IFS=$as_save_IFS
    6986 
    6987 fi
    6988 fi
    6989 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
    6990 if test -n "$ac_ct_STRIP"; then
    6991   { echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
    6992 echo "${ECHO_T}$ac_ct_STRIP" >&6; }
    6993 else
    6994   { echo "$as_me:$LINENO: result: no" >&5
    6995 echo "${ECHO_T}no" >&6; }
    6996 fi
    6997 
    6998   if test "x$ac_ct_STRIP" = x; then
    6999     STRIP=":"
    7000   else
    7001     case $cross_compiling:$ac_tool_warned in
    7002 yes:)
    7003 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    7004 whose name does not start with the host triplet.  If you think this
    7005 configuration is useful to you, please write to autoconf@gnu.org." >&5
    7006 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    7007 whose name does not start with the host triplet.  If you think this
    7008 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    7009 ac_tool_warned=yes ;;
    7010 esac
    7011     STRIP=$ac_ct_STRIP
    7012   fi
    7013 else
    7014   STRIP="$ac_cv_prog_STRIP"
    7015 fi
    7016 
    70177210
    70187211old_CC="$CC"
     
    70207213
    70217214# Set sane defaults for various variables
    7022 test -z "$AR" && AR=ar
    7023 test -z "$AR_FLAGS" && AR_FLAGS=cru
    7024 test -z "$AS" && AS=as
    70257215test -z "$CC" && CC=cc
    70267216test -z "$LTCC" && LTCC=$CC
    70277217test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
    7028 test -z "$DLLTOOL" && DLLTOOL=dlltool
    70297218test -z "$LD" && LD=ld
    7030 test -z "$LN_S" && LN_S="ln -s"
    7031 test -z "$MAGIC_CMD" && MAGIC_CMD=file
    7032 test -z "$NM" && NM=nm
    7033 test -z "$SED" && SED=sed
    7034 test -z "$OBJDUMP" && OBJDUMP=objdump
    7035 test -z "$RANLIB" && RANLIB=:
    7036 test -z "$STRIP" && STRIP=:
    70377219test -z "$ac_objext" && ac_objext=o
    7038 
    7039 # Determine commands to create old-style static archives.
    7040 old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
    7041 old_postinstall_cmds='chmod 644 $oldlib'
    7042 old_postuninstall_cmds=
    7043 
    7044 if test -n "$RANLIB"; then
    7045   case $host_os in
    7046   openbsd*)
    7047     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
    7048     ;;
    7049   *)
    7050     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
    7051     ;;
    7052   esac
    7053   old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
    7054 fi
    70557220
    70567221for cc_temp in $compiler""; do
     
    70627227  esac
    70637228done
    7064 cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
     7229cc_basename=`$ECHO "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
    70657230
    70667231
    70677232# Only perform the check for file, if the check method requires it
     7233test -z "$MAGIC_CMD" && MAGIC_CMD=file
    70687234case $deplibs_check_method in
    70697235file_magic*)
     
    70967262            :
    70977263          else
    7098             cat <<EOF 1>&2
     7264            cat <<_LT_EOF 1>&2
    70997265
    71007266*** Warning: the command libtool uses to detect shared libraries,
     
    71077273*** bug-libtool@gnu.org
    71087274
    7109 EOF
     7275_LT_EOF
    71107276          fi ;;
    71117277        esac
     
    71287294echo "${ECHO_T}no" >&6; }
    71297295fi
     7296
     7297
     7298
     7299
    71307300
    71317301if test -z "$lt_cv_path_MAGIC_CMD"; then
     
    71587328            :
    71597329          else
    7160             cat <<EOF 1>&2
     7330            cat <<_LT_EOF 1>&2
    71617331
    71627332*** Warning: the command libtool uses to detect shared libraries,
     
    71697339*** bug-libtool@gnu.org
    71707340
    7171 EOF
     7341_LT_EOF
    71727342          fi ;;
    71737343        esac
     
    71917361fi
    71927362
     7363
    71937364  else
    71947365    MAGIC_CMD=:
     
    72007371esac
    72017372
     7373# Use C for the default configuration in the libtool script
     7374
     7375lt_save_CC="$CC"
     7376ac_ext=c
     7377ac_cpp='$CPP $CPPFLAGS'
     7378ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     7379ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     7380ac_compiler_gnu=$ac_cv_c_compiler_gnu
     7381
     7382
     7383# Source file extension for C test sources.
     7384ac_ext=c
     7385
     7386# Object file extension for compiled C test sources.
     7387objext=o
     7388objext=$objext
     7389
     7390# Code to be used in simple compile tests
     7391lt_simple_compile_test_code="int some_variable = 0;"
     7392
     7393# Code to be used in simple link tests
     7394lt_simple_link_test_code='int main(){return(0);}'
     7395
     7396
     7397
     7398
     7399
     7400
     7401
     7402# If no C compiler was specified, use CC.
     7403LTCC=${LTCC-"$CC"}
     7404
     7405# If no C compiler flags were specified, use CFLAGS.
     7406LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
     7407
     7408# Allow CC to be a program name with arguments.
     7409compiler=$CC
     7410
     7411# Save the default compiler, since it gets overwritten when the other
     7412# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
     7413compiler_DEFAULT=$CC
     7414
     7415# save warnings/boilerplate of simple test code
     7416ac_outfile=conftest.$ac_objext
     7417echo "$lt_simple_compile_test_code" >conftest.$ac_ext
     7418eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
     7419_lt_compiler_boilerplate=`cat conftest.err`
     7420$RM conftest*
     7421
     7422ac_outfile=conftest.$ac_objext
     7423echo "$lt_simple_link_test_code" >conftest.$ac_ext
     7424eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
     7425_lt_linker_boilerplate=`cat conftest.err`
     7426$RM -r conftest*
     7427
     7428
     7429## CAVEAT EMPTOR:
     7430## There is no encapsulation within the following macros, do not change
     7431## the running order or otherwise move them around unless you know exactly
     7432## what you are doing...
     7433if test -n "$compiler"; then
     7434
     7435lt_prog_compiler_no_builtin_flag=
     7436
     7437if test "$GCC" = yes; then
     7438  lt_prog_compiler_no_builtin_flag=' -fno-builtin'
     7439
     7440  { echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
     7441echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6; }
     7442if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
     7443  echo $ECHO_N "(cached) $ECHO_C" >&6
     7444else
     7445  lt_cv_prog_compiler_rtti_exceptions=no
     7446   ac_outfile=conftest.$ac_objext
     7447   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
     7448   lt_compiler_flag="-fno-rtti -fno-exceptions"
     7449   # Insert the option either (1) after the last *FLAGS variable, or
     7450   # (2) before a word containing "conftest.", or (3) at the end.
     7451   # Note that $ac_compile itself does not contain backslashes and begins
     7452   # with a dollar sign (not a hyphen), so the echo should work correctly.
     7453   # The option is referenced via a variable to avoid confusing sed.
     7454   lt_compile=`echo "$ac_compile" | $SED \
     7455   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     7456   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     7457   -e 's:$: $lt_compiler_flag:'`
     7458   (eval echo "\"\$as_me:7458: $lt_compile\"" >&5)
     7459   (eval "$lt_compile" 2>conftest.err)
     7460   ac_status=$?
     7461   cat conftest.err >&5
     7462   echo "$as_me:7462: \$? = $ac_status" >&5
     7463   if (exit $ac_status) && test -s "$ac_outfile"; then
     7464     # The compiler can only warn and ignore the option if not recognized
     7465     # So say no if there are warnings other than the usual output.
     7466     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
     7467     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     7468     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
     7469       lt_cv_prog_compiler_rtti_exceptions=yes
     7470     fi
     7471   fi
     7472   $RM conftest*
     7473
     7474fi
     7475{ echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
     7476echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6; }
     7477
     7478if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
     7479    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
     7480else
     7481    :
     7482fi
     7483
     7484fi
     7485
     7486
     7487
     7488
     7489
     7490
     7491  lt_prog_compiler_wl=
     7492lt_prog_compiler_pic=
     7493lt_prog_compiler_static=
     7494
     7495{ echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
     7496echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6; }
     7497
     7498  if test "$GCC" = yes; then
     7499    lt_prog_compiler_wl='-Wl,'
     7500    lt_prog_compiler_static='-static'
     7501
     7502    case $host_os in
     7503      aix*)
     7504      # All AIX code is PIC.
     7505      if test "$host_cpu" = ia64; then
     7506        # AIX 5 now supports IA64 processor
     7507        lt_prog_compiler_static='-Bstatic'
     7508      fi
     7509      ;;
     7510
     7511    amigaos*)
     7512      case $host_cpu in
     7513      powerpc)
     7514            # see comment about AmigaOS4 .so support
     7515            lt_prog_compiler_pic='-fPIC'
     7516        ;;
     7517      m68k)
     7518            # FIXME: we need at least 68020 code to build shared libraries, but
     7519            # adding the `-m68020' flag to GCC prevents building anything better,
     7520            # like `-m68040'.
     7521            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
     7522        ;;
     7523      esac
     7524      ;;
     7525
     7526    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
     7527      # PIC is the default for these OSes.
     7528      ;;
     7529
     7530    mingw* | cygwin* | pw32* | os2*)
     7531      # This hack is so that the source file can tell whether it is being
     7532      # built for inclusion in a dll (and should export symbols for example).
     7533      # Although the cygwin gcc ignores -fPIC, still need this for old-style
     7534      # (--disable-auto-import) libraries
     7535      lt_prog_compiler_pic='-DDLL_EXPORT'
     7536      ;;
     7537
     7538    darwin* | rhapsody*)
     7539      # PIC is the default on this platform
     7540      # Common symbols not allowed in MH_DYLIB files
     7541      lt_prog_compiler_pic='-fno-common'
     7542      ;;
     7543
     7544    hpux*)
     7545      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
     7546      # not for PA HP-UX.
     7547      case $host_cpu in
     7548      hppa*64*|ia64*)
     7549        # +Z the default
     7550        ;;
     7551      *)
     7552        lt_prog_compiler_pic='-fPIC'
     7553        ;;
     7554      esac
     7555      ;;
     7556
     7557    interix[3-9]*)
     7558      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
     7559      # Instead, we relocate shared libraries at runtime.
     7560      ;;
     7561
     7562    msdosdjgpp*)
     7563      # Just because we use GCC doesn't mean we suddenly get shared libraries
     7564      # on systems that don't support them.
     7565      lt_prog_compiler_can_build_shared=no
     7566      enable_shared=no
     7567      ;;
     7568
     7569    *nto* | *qnx*)
     7570      # QNX uses GNU C++, but need to define -shared option too, otherwise
     7571      # it will coredump.
     7572      lt_prog_compiler_pic='-fPIC -shared'
     7573      ;;
     7574
     7575    sysv4*MP*)
     7576      if test -d /usr/nec; then
     7577        lt_prog_compiler_pic=-Kconform_pic
     7578      fi
     7579      ;;
     7580
     7581    *)
     7582      lt_prog_compiler_pic='-fPIC'
     7583      ;;
     7584    esac
     7585  else
     7586    # PORTME Check for flag to pass linker flags through the system compiler.
     7587    case $host_os in
     7588    aix*)
     7589      lt_prog_compiler_wl='-Wl,'
     7590      if test "$host_cpu" = ia64; then
     7591        # AIX 5 now supports IA64 processor
     7592        lt_prog_compiler_static='-Bstatic'
     7593      else
     7594        lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
     7595      fi
     7596      ;;
     7597
     7598    mingw* | cygwin* | pw32* | os2*)
     7599      # This hack is so that the source file can tell whether it is being
     7600      # built for inclusion in a dll (and should export symbols for example).
     7601      lt_prog_compiler_pic='-DDLL_EXPORT'
     7602      ;;
     7603
     7604    hpux9* | hpux10* | hpux11*)
     7605      lt_prog_compiler_wl='-Wl,'
     7606      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
     7607      # not for PA HP-UX.
     7608      case $host_cpu in
     7609      hppa*64*|ia64*)
     7610        # +Z the default
     7611        ;;
     7612      *)
     7613        lt_prog_compiler_pic='+Z'
     7614        ;;
     7615      esac
     7616      # Is there a better lt_prog_compiler_static that works with the bundled CC?
     7617      lt_prog_compiler_static='${wl}-a ${wl}archive'
     7618      ;;
     7619
     7620    irix5* | irix6* | nonstopux*)
     7621      lt_prog_compiler_wl='-Wl,'
     7622      # PIC (with -KPIC) is the default.
     7623      lt_prog_compiler_static='-non_shared'
     7624      ;;
     7625
     7626    linux* | k*bsd*-gnu)
     7627      case $cc_basename in
     7628      icc* | ecc* | ifort*)
     7629        lt_prog_compiler_wl='-Wl,'
     7630        lt_prog_compiler_pic='-KPIC'
     7631        lt_prog_compiler_static='-static'
     7632        ;;
     7633      pgcc* | pgf77* | pgf90* | pgf95*)
     7634        # Portland Group compilers (*not* the Pentium gcc compiler,
     7635        # which looks to be a dead project)
     7636        lt_prog_compiler_wl='-Wl,'
     7637        lt_prog_compiler_pic='-fpic'
     7638        lt_prog_compiler_static='-Bstatic'
     7639        ;;
     7640      ccc*)
     7641        lt_prog_compiler_wl='-Wl,'
     7642        # All Alpha code is PIC.
     7643        lt_prog_compiler_static='-non_shared'
     7644        ;;
     7645      xl*)
     7646        # IBM XL C 8.0/Fortran 10.1 on PPC
     7647        lt_prog_compiler_wl='-Wl,'
     7648        lt_prog_compiler_pic='-qpic'
     7649        lt_prog_compiler_static='-qstaticlink'
     7650        ;;
     7651      *)
     7652        case `$CC -V 2>&1 | sed 5q` in
     7653        *Sun\ C*)
     7654          # Sun C 5.9
     7655          lt_prog_compiler_pic='-KPIC'
     7656          lt_prog_compiler_static='-Bstatic'
     7657          lt_prog_compiler_wl='-Wl,'
     7658          ;;
     7659        *Sun\ F*)
     7660          # Sun Fortran 8.3 passes all unrecognized flags to the linker
     7661          lt_prog_compiler_pic='-KPIC'
     7662          lt_prog_compiler_static='-Bstatic'
     7663          lt_prog_compiler_wl=''
     7664          ;;
     7665        esac
     7666        ;;
     7667      esac
     7668      ;;
     7669
     7670    newsos6)
     7671      lt_prog_compiler_pic='-KPIC'
     7672      lt_prog_compiler_static='-Bstatic'
     7673      ;;
     7674
     7675    *nto* | *qnx*)
     7676      # QNX uses GNU C++, but need to define -shared option too, otherwise
     7677      # it will coredump.
     7678      lt_prog_compiler_pic='-fPIC -shared'
     7679      ;;
     7680
     7681    osf3* | osf4* | osf5*)
     7682      lt_prog_compiler_wl='-Wl,'
     7683      # All OSF/1 code is PIC.
     7684      lt_prog_compiler_static='-non_shared'
     7685      ;;
     7686
     7687    rdos*)
     7688      lt_prog_compiler_static='-non_shared'
     7689      ;;
     7690
     7691    solaris*)
     7692      lt_prog_compiler_pic='-KPIC'
     7693      lt_prog_compiler_static='-Bstatic'
     7694      case $cc_basename in
     7695      f77* | f90* | f95*)
     7696        lt_prog_compiler_wl='-Qoption ld ';;
     7697      *)
     7698        lt_prog_compiler_wl='-Wl,';;
     7699      esac
     7700      ;;
     7701
     7702    sunos4*)
     7703      lt_prog_compiler_wl='-Qoption ld '
     7704      lt_prog_compiler_pic='-PIC'
     7705      lt_prog_compiler_static='-Bstatic'
     7706      ;;
     7707
     7708    sysv4 | sysv4.2uw2* | sysv4.3*)
     7709      lt_prog_compiler_wl='-Wl,'
     7710      lt_prog_compiler_pic='-KPIC'
     7711      lt_prog_compiler_static='-Bstatic'
     7712      ;;
     7713
     7714    sysv4*MP*)
     7715      if test -d /usr/nec ;then
     7716        lt_prog_compiler_pic='-Kconform_pic'
     7717        lt_prog_compiler_static='-Bstatic'
     7718      fi
     7719      ;;
     7720
     7721    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
     7722      lt_prog_compiler_wl='-Wl,'
     7723      lt_prog_compiler_pic='-KPIC'
     7724      lt_prog_compiler_static='-Bstatic'
     7725      ;;
     7726
     7727    unicos*)
     7728      lt_prog_compiler_wl='-Wl,'
     7729      lt_prog_compiler_can_build_shared=no
     7730      ;;
     7731
     7732    uts4*)
     7733      lt_prog_compiler_pic='-pic'
     7734      lt_prog_compiler_static='-Bstatic'
     7735      ;;
     7736
     7737    *)
     7738      lt_prog_compiler_can_build_shared=no
     7739      ;;
     7740    esac
     7741  fi
     7742
     7743case $host_os in
     7744  # For platforms which do not support PIC, -DPIC is meaningless:
     7745  *djgpp*)
     7746    lt_prog_compiler_pic=
     7747    ;;
     7748  *)
     7749    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
     7750    ;;
     7751esac
     7752{ echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5
     7753echo "${ECHO_T}$lt_prog_compiler_pic" >&6; }
     7754
     7755
     7756
     7757
     7758
     7759
     7760#
     7761# Check to make sure the PIC flag actually works.
     7762#
     7763if test -n "$lt_prog_compiler_pic"; then
     7764  { echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
     7765echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic works... $ECHO_C" >&6; }
     7766if test "${lt_cv_prog_compiler_pic_works+set}" = set; then
     7767  echo $ECHO_N "(cached) $ECHO_C" >&6
     7768else
     7769  lt_cv_prog_compiler_pic_works=no
     7770   ac_outfile=conftest.$ac_objext
     7771   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
     7772   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
     7773   # Insert the option either (1) after the last *FLAGS variable, or
     7774   # (2) before a word containing "conftest.", or (3) at the end.
     7775   # Note that $ac_compile itself does not contain backslashes and begins
     7776   # with a dollar sign (not a hyphen), so the echo should work correctly.
     7777   # The option is referenced via a variable to avoid confusing sed.
     7778   lt_compile=`echo "$ac_compile" | $SED \
     7779   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     7780   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     7781   -e 's:$: $lt_compiler_flag:'`
     7782   (eval echo "\"\$as_me:7782: $lt_compile\"" >&5)
     7783   (eval "$lt_compile" 2>conftest.err)
     7784   ac_status=$?
     7785   cat conftest.err >&5
     7786   echo "$as_me:7786: \$? = $ac_status" >&5
     7787   if (exit $ac_status) && test -s "$ac_outfile"; then
     7788     # The compiler can only warn and ignore the option if not recognized
     7789     # So say no if there are warnings other than the usual output.
     7790     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
     7791     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     7792     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
     7793       lt_cv_prog_compiler_pic_works=yes
     7794     fi
     7795   fi
     7796   $RM conftest*
     7797
     7798fi
     7799{ echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_pic_works" >&5
     7800echo "${ECHO_T}$lt_cv_prog_compiler_pic_works" >&6; }
     7801
     7802if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
     7803    case $lt_prog_compiler_pic in
     7804     "" | " "*) ;;
     7805     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
     7806     esac
     7807else
     7808    lt_prog_compiler_pic=
     7809     lt_prog_compiler_can_build_shared=no
     7810fi
     7811
     7812fi
     7813
     7814
     7815
     7816
     7817
     7818
     7819#
     7820# Check to make sure the static flag actually works.
     7821#
     7822wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
     7823{ echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
     7824echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6; }
     7825if test "${lt_cv_prog_compiler_static_works+set}" = set; then
     7826  echo $ECHO_N "(cached) $ECHO_C" >&6
     7827else
     7828  lt_cv_prog_compiler_static_works=no
     7829   save_LDFLAGS="$LDFLAGS"
     7830   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
     7831   echo "$lt_simple_link_test_code" > conftest.$ac_ext
     7832   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
     7833     # The linker can only warn and ignore the option if not recognized
     7834     # So say no if there are warnings
     7835     if test -s conftest.err; then
     7836       # Append any errors to the config.log.
     7837       cat conftest.err 1>&5
     7838       $ECHO "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
     7839       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     7840       if diff conftest.exp conftest.er2 >/dev/null; then
     7841         lt_cv_prog_compiler_static_works=yes
     7842       fi
     7843     else
     7844       lt_cv_prog_compiler_static_works=yes
     7845     fi
     7846   fi
     7847   $RM -r conftest*
     7848   LDFLAGS="$save_LDFLAGS"
     7849
     7850fi
     7851{ echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_static_works" >&5
     7852echo "${ECHO_T}$lt_cv_prog_compiler_static_works" >&6; }
     7853
     7854if test x"$lt_cv_prog_compiler_static_works" = xyes; then
     7855    :
     7856else
     7857    lt_prog_compiler_static=
     7858fi
     7859
     7860
     7861
     7862
     7863
     7864
     7865
     7866  { echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
     7867echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6; }
     7868if test "${lt_cv_prog_compiler_c_o+set}" = set; then
     7869  echo $ECHO_N "(cached) $ECHO_C" >&6
     7870else
     7871  lt_cv_prog_compiler_c_o=no
     7872   $RM -r conftest 2>/dev/null
     7873   mkdir conftest
     7874   cd conftest
     7875   mkdir out
     7876   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
     7877
     7878   lt_compiler_flag="-o out/conftest2.$ac_objext"
     7879   # Insert the option either (1) after the last *FLAGS variable, or
     7880   # (2) before a word containing "conftest.", or (3) at the end.
     7881   # Note that $ac_compile itself does not contain backslashes and begins
     7882   # with a dollar sign (not a hyphen), so the echo should work correctly.
     7883   lt_compile=`echo "$ac_compile" | $SED \
     7884   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     7885   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     7886   -e 's:$: $lt_compiler_flag:'`
     7887   (eval echo "\"\$as_me:7887: $lt_compile\"" >&5)
     7888   (eval "$lt_compile" 2>out/conftest.err)
     7889   ac_status=$?
     7890   cat out/conftest.err >&5
     7891   echo "$as_me:7891: \$? = $ac_status" >&5
     7892   if (exit $ac_status) && test -s out/conftest2.$ac_objext
     7893   then
     7894     # The compiler can only warn and ignore the option if not recognized
     7895     # So say no if there are warnings
     7896     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
     7897     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     7898     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
     7899       lt_cv_prog_compiler_c_o=yes
     7900     fi
     7901   fi
     7902   chmod u+w . 2>&5
     7903   $RM conftest*
     7904   # SGI C++ compiler will create directory out/ii_files/ for
     7905   # template instantiation
     7906   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
     7907   $RM out/* && rmdir out
     7908   cd ..
     7909   $RM -r conftest
     7910   $RM conftest*
     7911
     7912fi
     7913{ echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
     7914echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6; }
     7915
     7916
     7917
     7918
     7919
     7920
     7921  { echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
     7922echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6; }
     7923if test "${lt_cv_prog_compiler_c_o+set}" = set; then
     7924  echo $ECHO_N "(cached) $ECHO_C" >&6
     7925else
     7926  lt_cv_prog_compiler_c_o=no
     7927   $RM -r conftest 2>/dev/null
     7928   mkdir conftest
     7929   cd conftest
     7930   mkdir out
     7931   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
     7932
     7933   lt_compiler_flag="-o out/conftest2.$ac_objext"
     7934   # Insert the option either (1) after the last *FLAGS variable, or
     7935   # (2) before a word containing "conftest.", or (3) at the end.
     7936   # Note that $ac_compile itself does not contain backslashes and begins
     7937   # with a dollar sign (not a hyphen), so the echo should work correctly.
     7938   lt_compile=`echo "$ac_compile" | $SED \
     7939   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     7940   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     7941   -e 's:$: $lt_compiler_flag:'`
     7942   (eval echo "\"\$as_me:7942: $lt_compile\"" >&5)
     7943   (eval "$lt_compile" 2>out/conftest.err)
     7944   ac_status=$?
     7945   cat out/conftest.err >&5
     7946   echo "$as_me:7946: \$? = $ac_status" >&5
     7947   if (exit $ac_status) && test -s out/conftest2.$ac_objext
     7948   then
     7949     # The compiler can only warn and ignore the option if not recognized
     7950     # So say no if there are warnings
     7951     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
     7952     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     7953     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
     7954       lt_cv_prog_compiler_c_o=yes
     7955     fi
     7956   fi
     7957   chmod u+w . 2>&5
     7958   $RM conftest*
     7959   # SGI C++ compiler will create directory out/ii_files/ for
     7960   # template instantiation
     7961   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
     7962   $RM out/* && rmdir out
     7963   cd ..
     7964   $RM -r conftest
     7965   $RM conftest*
     7966
     7967fi
     7968{ echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
     7969echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6; }
     7970
     7971
     7972
     7973
     7974hard_links="nottested"
     7975if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
     7976  # do not overwrite the value of need_locks provided by the user
     7977  { echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
     7978echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6; }
     7979  hard_links=yes
     7980  $RM conftest*
     7981  ln conftest.a conftest.b 2>/dev/null && hard_links=no
     7982  touch conftest.a
     7983  ln conftest.a conftest.b 2>&5 || hard_links=no
     7984  ln conftest.a conftest.b 2>/dev/null && hard_links=no
     7985  { echo "$as_me:$LINENO: result: $hard_links" >&5
     7986echo "${ECHO_T}$hard_links" >&6; }
     7987  if test "$hard_links" = no; then
     7988    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
     7989echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
     7990    need_locks=warn
     7991  fi
     7992else
     7993  need_locks=no
     7994fi
     7995
     7996
     7997
     7998
     7999
     8000
     8001  { echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
     8002echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6; }
     8003
     8004  runpath_var=
     8005  allow_undefined_flag=
     8006  always_export_symbols=no
     8007  archive_cmds=
     8008  archive_expsym_cmds=
     8009  compiler_needs_object=no
     8010  enable_shared_with_static_runtimes=no
     8011  export_dynamic_flag_spec=
     8012  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
     8013  hardcode_automatic=no
     8014  hardcode_direct=no
     8015  hardcode_direct_absolute=no
     8016  hardcode_libdir_flag_spec=
     8017  hardcode_libdir_flag_spec_ld=
     8018  hardcode_libdir_separator=
     8019  hardcode_minus_L=no
     8020  hardcode_shlibpath_var=unsupported
     8021  inherit_rpath=no
     8022  link_all_deplibs=unknown
     8023  module_cmds=
     8024  module_expsym_cmds=
     8025  old_archive_from_new_cmds=
     8026  old_archive_from_expsyms_cmds=
     8027  thread_safe_flag_spec=
     8028  whole_archive_flag_spec=
     8029  # include_expsyms should be a list of space-separated symbols to be *always*
     8030  # included in the symbol list
     8031  include_expsyms=
     8032  # exclude_expsyms can be an extended regexp of symbols to exclude
     8033  # it will be wrapped by ` (' and `)$', so one must not match beginning or
     8034  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
     8035  # as well as any symbol that contains `d'.
     8036  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
     8037  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
     8038  # platforms (ab)use it in PIC code, but their linkers get confused if
     8039  # the symbol is explicitly referenced.  Since portable code cannot
     8040  # rely on this symbol name, it's probably fine to never include it in
     8041  # preloaded symbol tables.
     8042  # Exclude shared library initialization/finalization symbols.
     8043  extract_expsyms_cmds=
    72028044
    72038045  case $host_os in
    7204     rhapsody* | darwin*)
    7205     if test -n "$ac_tool_prefix"; then
    7206   # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
    7207 set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
    7208 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    7209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    7210 if test "${ac_cv_prog_DSYMUTIL+set}" = set; then
    7211   echo $ECHO_N "(cached) $ECHO_C" >&6
    7212 else
    7213   if test -n "$DSYMUTIL"; then
    7214   ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
    7215 else
    7216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7217 for as_dir in $PATH
    7218 do
    7219   IFS=$as_save_IFS
    7220   test -z "$as_dir" && as_dir=.
    7221   for ac_exec_ext in '' $ac_executable_extensions; do
    7222   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    7223     ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
    7224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    7225     break 2
    7226   fi
    7227 done
    7228 done
    7229 IFS=$as_save_IFS
    7230 
    7231 fi
    7232 fi
    7233 DSYMUTIL=$ac_cv_prog_DSYMUTIL
    7234 if test -n "$DSYMUTIL"; then
    7235   { echo "$as_me:$LINENO: result: $DSYMUTIL" >&5
    7236 echo "${ECHO_T}$DSYMUTIL" >&6; }
    7237 else
    7238   { echo "$as_me:$LINENO: result: no" >&5
    7239 echo "${ECHO_T}no" >&6; }
    7240 fi
    7241 
    7242 
    7243 fi
    7244 if test -z "$ac_cv_prog_DSYMUTIL"; then
    7245   ac_ct_DSYMUTIL=$DSYMUTIL
    7246   # Extract the first word of "dsymutil", so it can be a program name with args.
    7247 set dummy dsymutil; ac_word=$2
    7248 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    7249 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    7250 if test "${ac_cv_prog_ac_ct_DSYMUTIL+set}" = set; then
    7251   echo $ECHO_N "(cached) $ECHO_C" >&6
    7252 else
    7253   if test -n "$ac_ct_DSYMUTIL"; then
    7254   ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
    7255 else
    7256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7257 for as_dir in $PATH
    7258 do
    7259   IFS=$as_save_IFS
    7260   test -z "$as_dir" && as_dir=.
    7261   for ac_exec_ext in '' $ac_executable_extensions; do
    7262   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    7263     ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
    7264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    7265     break 2
    7266   fi
    7267 done
    7268 done
    7269 IFS=$as_save_IFS
    7270 
    7271 fi
    7272 fi
    7273 ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
    7274 if test -n "$ac_ct_DSYMUTIL"; then
    7275   { echo "$as_me:$LINENO: result: $ac_ct_DSYMUTIL" >&5
    7276 echo "${ECHO_T}$ac_ct_DSYMUTIL" >&6; }
    7277 else
    7278   { echo "$as_me:$LINENO: result: no" >&5
    7279 echo "${ECHO_T}no" >&6; }
    7280 fi
    7281 
    7282   if test "x$ac_ct_DSYMUTIL" = x; then
    7283     DSYMUTIL=":"
     8046  cygwin* | mingw* | pw32*)
     8047    # FIXME: the MSVC++ port hasn't been tested in a loooong time
     8048    # When not using gcc, we currently assume that we are using
     8049    # Microsoft Visual C++.
     8050    if test "$GCC" != yes; then
     8051      with_gnu_ld=no
     8052    fi
     8053    ;;
     8054  interix*)
     8055    # we just hope/assume this is gcc and not c89 (= MSVC++)
     8056    with_gnu_ld=yes
     8057    ;;
     8058  openbsd*)
     8059    with_gnu_ld=no
     8060    ;;
     8061  esac
     8062
     8063  ld_shlibs=yes
     8064  if test "$with_gnu_ld" = yes; then
     8065    # If archive_cmds runs LD, not CC, wlarc should be empty
     8066    wlarc='${wl}'
     8067
     8068    # Set some defaults for GNU ld with shared library support. These
     8069    # are reset later if shared libraries are not supported. Putting them
     8070    # here allows them to be overridden if necessary.
     8071    runpath_var=LD_RUN_PATH
     8072    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
     8073    export_dynamic_flag_spec='${wl}--export-dynamic'
     8074    # ancient GNU ld didn't support --whole-archive et. al.
     8075    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
     8076      whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
     8077    else
     8078      whole_archive_flag_spec=
     8079    fi
     8080    supports_anon_versioning=no
     8081    case `$LD -v 2>&1` in
     8082      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
     8083      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
     8084      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
     8085      *\ 2.11.*) ;; # other 2.11 versions
     8086      *) supports_anon_versioning=yes ;;
     8087    esac
     8088
     8089    # See if GNU ld supports shared libraries.
     8090    case $host_os in
     8091    aix[3-9]*)
     8092      # On AIX/PPC, the GNU linker is very broken
     8093      if test "$host_cpu" != ia64; then
     8094        ld_shlibs=no
     8095        cat <<_LT_EOF 1>&2
     8096
     8097*** Warning: the GNU linker, at least up to release 2.9.1, is reported
     8098*** to be unable to reliably create shared libraries on AIX.
     8099*** Therefore, libtool is disabling shared libraries support.  If you
     8100*** really care for shared libraries, you may want to modify your PATH
     8101*** so that a non-GNU linker is found, and then restart.
     8102
     8103_LT_EOF
     8104      fi
     8105      ;;
     8106
     8107    amigaos*)
     8108      case $host_cpu in
     8109      powerpc)
     8110            # see comment about AmigaOS4 .so support
     8111            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8112            archive_expsym_cmds=''
     8113        ;;
     8114      m68k)
     8115            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)'
     8116            hardcode_libdir_flag_spec='-L$libdir'
     8117            hardcode_minus_L=yes
     8118        ;;
     8119      esac
     8120      ;;
     8121
     8122    beos*)
     8123      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
     8124        allow_undefined_flag=unsupported
     8125        # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
     8126        # support --undefined.  This deserves some investigation.  FIXME
     8127        archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8128      else
     8129        ld_shlibs=no
     8130      fi
     8131      ;;
     8132
     8133    cygwin* | mingw* | pw32*)
     8134      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
     8135      # as there is no search path for DLLs.
     8136      hardcode_libdir_flag_spec='-L$libdir'
     8137      allow_undefined_flag=unsupported
     8138      always_export_symbols=no
     8139      enable_shared_with_static_runtimes=yes
     8140      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
     8141
     8142      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
     8143        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
     8144        # If the export-symbols file already is a .def file (1st line
     8145        # is EXPORTS), use it as is; otherwise, prepend...
     8146        archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
     8147          cp $export_symbols $output_objdir/$soname.def;
     8148        else
     8149          echo EXPORTS > $output_objdir/$soname.def;
     8150          cat $export_symbols >> $output_objdir/$soname.def;
     8151        fi~
     8152        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
     8153      else
     8154        ld_shlibs=no
     8155      fi
     8156      ;;
     8157
     8158    interix[3-9]*)
     8159      hardcode_direct=no
     8160      hardcode_shlibpath_var=no
     8161      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
     8162      export_dynamic_flag_spec='${wl}-E'
     8163      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
     8164      # Instead, shared libraries are loaded at an image base (0x10000000 by
     8165      # default) and relocated if they conflict, which is a slow very memory
     8166      # consuming and fragmenting process.  To avoid this, we pick a random,
     8167      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
     8168      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
     8169      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
     8170      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
     8171      ;;
     8172
     8173    gnu* | linux* | tpf* | k*bsd*-gnu)
     8174      tmp_diet=no
     8175      if test "$host_os" = linux-dietlibc; then
     8176        case $cc_basename in
     8177          diet\ *) tmp_diet=yes;;       # linux-dietlibc with static linking (!diet-dyn)
     8178        esac
     8179      fi
     8180      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
     8181         && test "$tmp_diet" = no
     8182      then
     8183        tmp_addflag=
     8184        tmp_sharedflag='-shared'
     8185        case $cc_basename,$host_cpu in
     8186        pgcc*)                          # Portland Group C compiler
     8187          whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
     8188          tmp_addflag=' $pic_flag'
     8189          ;;
     8190        pgf77* | pgf90* | pgf95*)       # Portland Group f77 and f90 compilers
     8191          whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
     8192          tmp_addflag=' $pic_flag -Mnomain' ;;
     8193        ecc*,ia64* | icc*,ia64*)        # Intel C compiler on ia64
     8194          tmp_addflag=' -i_dynamic' ;;
     8195        efc*,ia64* | ifort*,ia64*)      # Intel Fortran compiler on ia64
     8196          tmp_addflag=' -i_dynamic -nofor_main' ;;
     8197        ifc* | ifort*)                  # Intel Fortran compiler
     8198          tmp_addflag=' -nofor_main' ;;
     8199        xl[cC]*)                        # IBM XL C 8.0 on PPC (deal with xlf below)
     8200          tmp_sharedflag='-qmkshrobj'
     8201          tmp_addflag= ;;
     8202        esac
     8203        case `$CC -V 2>&1 | sed 5q` in
     8204        *Sun\ C*)                       # Sun C 5.9
     8205          whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
     8206          compiler_needs_object=yes
     8207          tmp_sharedflag='-G' ;;
     8208        *Sun\ F*)                       # Sun Fortran 8.3
     8209          tmp_sharedflag='-G' ;;
     8210        esac
     8211        archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8212
     8213        if test "x$supports_anon_versioning" = xyes; then
     8214          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
     8215            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
     8216            echo "local: *; };" >> $output_objdir/$libname.ver~
     8217            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
     8218        fi
     8219
     8220        case $cc_basename in
     8221        xlf*)
     8222          # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
     8223          whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
     8224          hardcode_libdir_flag_spec=
     8225          hardcode_libdir_flag_spec_ld='-rpath $libdir'
     8226          archive_cmds='$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -o $lib'
     8227          if test "x$supports_anon_versioning" = xyes; then
     8228            archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
     8229              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
     8230              echo "local: *; };" >> $output_objdir/$libname.ver~
     8231              $LD -shared $libobjs $deplibs $compiler_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
     8232          fi
     8233          ;;
     8234        esac
     8235      else
     8236        ld_shlibs=no
     8237      fi
     8238      ;;
     8239
     8240    netbsd* | netbsdelf*-gnu)
     8241      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
     8242        archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
     8243        wlarc=
     8244      else
     8245        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8246        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
     8247      fi
     8248      ;;
     8249
     8250    solaris*)
     8251      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
     8252        ld_shlibs=no
     8253        cat <<_LT_EOF 1>&2
     8254
     8255*** Warning: The releases 2.8.* of the GNU linker cannot reliably
     8256*** create shared libraries on Solaris systems.  Therefore, libtool
     8257*** is disabling shared libraries support.  We urge you to upgrade GNU
     8258*** binutils to release 2.9.1 or newer.  Another option is to modify
     8259*** your PATH or compiler configuration so that the native linker is
     8260*** used, and then restart.
     8261
     8262_LT_EOF
     8263      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
     8264        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8265        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
     8266      else
     8267        ld_shlibs=no
     8268      fi
     8269      ;;
     8270
     8271    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
     8272      case `$LD -v 2>&1` in
     8273        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
     8274        ld_shlibs=no
     8275        cat <<_LT_EOF 1>&2
     8276
     8277*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
     8278*** reliably create shared libraries on SCO systems.  Therefore, libtool
     8279*** is disabling shared libraries support.  We urge you to upgrade GNU
     8280*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
     8281*** your PATH or compiler configuration so that the native linker is
     8282*** used, and then restart.
     8283
     8284_LT_EOF
     8285        ;;
     8286        *)
     8287          # For security reasons, it is highly recommended that you always
     8288          # use absolute paths for naming shared libraries, and exclude the
     8289          # DT_RUNPATH tag from executables and libraries.  But doing so
     8290          # requires that you compile everything twice, which is a pain.
     8291          if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
     8292            hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
     8293            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8294            archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
     8295          else
     8296            ld_shlibs=no
     8297          fi
     8298        ;;
     8299      esac
     8300      ;;
     8301
     8302    sunos4*)
     8303      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
     8304      wlarc=
     8305      hardcode_direct=yes
     8306      hardcode_shlibpath_var=no
     8307      ;;
     8308
     8309    *)
     8310      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
     8311        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
     8312        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
     8313      else
     8314        ld_shlibs=no
     8315      fi
     8316      ;;
     8317    esac
     8318
     8319    if test "$ld_shlibs" = no; then
     8320      runpath_var=
     8321      hardcode_libdir_flag_spec=
     8322      export_dynamic_flag_spec=
     8323      whole_archive_flag_spec=
     8324    fi
    72848325  else
    7285     case $cross_compiling:$ac_tool_warned in
    7286 yes:)
    7287 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    7288 whose name does not start with the host triplet.  If you think this
    7289 configuration is useful to you, please write to autoconf@gnu.org." >&5
    7290 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    7291 whose name does not start with the host triplet.  If you think this
    7292 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    7293 ac_tool_warned=yes ;;
    7294 esac
    7295     DSYMUTIL=$ac_ct_DSYMUTIL
    7296   fi
    7297 else
    7298   DSYMUTIL="$ac_cv_prog_DSYMUTIL"
    7299 fi
    7300 
    7301     if test -n "$ac_tool_prefix"; then
    7302   # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
    7303 set dummy ${ac_tool_prefix}nmedit; ac_word=$2
    7304 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    7305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    7306 if test "${ac_cv_prog_NMEDIT+set}" = set; then
    7307   echo $ECHO_N "(cached) $ECHO_C" >&6
    7308 else
    7309   if test -n "$NMEDIT"; then
    7310   ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
    7311 else
    7312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7313 for as_dir in $PATH
    7314 do
    7315   IFS=$as_save_IFS
    7316   test -z "$as_dir" && as_dir=.
    7317   for ac_exec_ext in '' $ac_executable_extensions; do
    7318   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    7319     ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
    7320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    7321     break 2
    7322   fi
    7323 done
    7324 done
    7325 IFS=$as_save_IFS
    7326 
    7327 fi
    7328 fi
    7329 NMEDIT=$ac_cv_prog_NMEDIT
    7330 if test -n "$NMEDIT"; then
    7331   { echo "$as_me:$LINENO: result: $NMEDIT" >&5
    7332 echo "${ECHO_T}$NMEDIT" >&6; }
    7333 else
    7334   { echo "$as_me:$LINENO: result: no" >&5
    7335 echo "${ECHO_T}no" >&6; }
    7336 fi
    7337 
    7338 
    7339 fi
    7340 if test -z "$ac_cv_prog_NMEDIT"; then
    7341   ac_ct_NMEDIT=$NMEDIT
    7342   # Extract the first word of "nmedit", so it can be a program name with args.
    7343 set dummy nmedit; ac_word=$2
    7344 { echo "$as_me:$LINENO: checking for $ac_word" >&5
    7345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
    7346 if test "${ac_cv_prog_ac_ct_NMEDIT+set}" = set; then
    7347   echo $ECHO_N "(cached) $ECHO_C" >&6
    7348 else
    7349   if test -n "$ac_ct_NMEDIT"; then
    7350   ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
    7351 else
    7352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7353 for as_dir in $PATH
    7354 do
    7355   IFS=$as_save_IFS
    7356   test -z "$as_dir" && as_dir=.
    7357   for ac_exec_ext in '' $ac_executable_extensions; do
    7358   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    7359     ac_cv_prog_ac_ct_NMEDIT="nmedit"
    7360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
    7361     break 2
    7362   fi
    7363 done
    7364 done
    7365 IFS=$as_save_IFS
    7366 
    7367 fi
    7368 fi
    7369 ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
    7370 if test -n "$ac_ct_NMEDIT"; then
    7371   { echo "$as_me:$LINENO: result: $ac_ct_NMEDIT" >&5
    7372 echo "${ECHO_T}$ac_ct_NMEDIT" >&6; }
    7373 else
    7374   { echo "$as_me:$LINENO: result: no" >&5
    7375 echo "${ECHO_T}no" >&6; }
    7376 fi
    7377 
    7378   if test "x$ac_ct_NMEDIT" = x; then
    7379     NMEDIT=":"
    7380   else
    7381     case $cross_compiling:$ac_tool_warned in
    7382 yes:)
    7383 { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
    7384 whose name does not start with the host triplet.  If you think this
    7385 configuration is useful to you, please write to autoconf@gnu.org." >&5
    7386 echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
    7387 whose name does not start with the host triplet.  If you think this
    7388 configuration is useful to you, please write to autoconf@gnu.org." >&2;}
    7389 ac_tool_warned=yes ;;
    7390 esac
    7391     NMEDIT=$ac_ct_NMEDIT
    7392   fi
    7393 else
    7394   NMEDIT="$ac_cv_prog_NMEDIT"
    7395 fi
    7396 
    7397 
    7398     { echo "$as_me:$LINENO: checking for -single_module linker flag" >&5
    7399 echo $ECHO_N "checking for -single_module linker flag... $ECHO_C" >&6; }
    7400 if test "${lt_cv_apple_cc_single_mod+set}" = set; then
    7401   echo $ECHO_N "(cached) $ECHO_C" >&6
    7402 else
    7403   lt_cv_apple_cc_single_mod=no
    7404       if test -z "${LT_MULTI_MODULE}"; then
    7405    # By default we will add the -single_module flag. You can override
    7406    # by either setting the environment variable LT_MULTI_MODULE
    7407    # non-empty at configure time, or by adding -multi_module to the
    7408    # link flags.
    7409    echo "int foo(void){return 1;}" > conftest.c
    7410    $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
    7411      -dynamiclib ${wl}-single_module conftest.c
    7412    if test -f libconftest.dylib; then
    7413      lt_cv_apple_cc_single_mod=yes
    7414      rm -rf libconftest.dylib*
    7415    fi
    7416    rm conftest.c
     8326    # PORTME fill in a description of your system's linker (not GNU ld)
     8327    case $host_os in
     8328    aix3*)
     8329      allow_undefined_flag=unsupported
     8330      always_export_symbols=yes
     8331      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
     8332      # Note: this linker hardcodes the directories in LIBPATH if there
     8333      # are no directories specified by -L.
     8334      hardcode_minus_L=yes
     8335      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
     8336        # Neither direct hardcoding nor static linking is supported with a
     8337        # broken collect2.
     8338        hardcode_direct=unsupported
    74178339      fi
    7418 fi
    7419 { echo "$as_me:$LINENO: result: $lt_cv_apple_cc_single_mod" >&5
    7420 echo "${ECHO_T}$lt_cv_apple_cc_single_mod" >&6; }
    7421     { echo "$as_me:$LINENO: checking for -exported_symbols_list linker flag" >&5
    7422 echo $ECHO_N "checking for -exported_symbols_list linker flag... $ECHO_C" >&6; }
    7423 if test "${lt_cv_ld_exported_symbols_list+set}" = set; then
    7424   echo $ECHO_N "(cached) $ECHO_C" >&6
    7425 else
    7426   lt_cv_ld_exported_symbols_list=no
    7427       save_LDFLAGS=$LDFLAGS
    7428       echo "_main" > conftest.sym
    7429       LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
    7430       cat >conftest.$ac_ext <<_ACEOF
     8340      ;;
     8341
     8342    aix[4-9]*)
     8343      if test "$host_cpu" = ia64; then
     8344        # On IA64, the linker does run time linking by default, so we don't
     8345        # have to do anything special.
     8346        aix_use_runtimelinking=no
     8347        exp_sym_flag='-Bexport'
     8348        no_entry_flag=""
     8349      else
     8350        # If we're using GNU nm, then we don't want the "-C" option.
     8351        # -C means demangle to AIX nm, but means don't demangle with GNU nm
     8352        if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
     8353          export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
     8354        else
     8355          export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
     8356        fi
     8357        aix_use_runtimelinking=no
     8358
     8359        # Test if we are trying to use run time linking or normal
     8360        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
     8361        # need to do runtime linking.
     8362        case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
     8363          for ld_flag in $LDFLAGS; do
     8364          if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
     8365            aix_use_runtimelinking=yes
     8366            break
     8367          fi
     8368          done
     8369          ;;
     8370        esac
     8371
     8372        exp_sym_flag='-bexport'
     8373        no_entry_flag='-bnoentry'
     8374      fi
     8375
     8376      # When large executables or shared objects are built, AIX ld can
     8377      # have problems creating the table of contents.  If linking a library
     8378      # or program results in "error TOC overflow" add -mminimal-toc to
     8379      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
     8380      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
     8381
     8382      archive_cmds=''
     8383      hardcode_direct=yes
     8384      hardcode_direct_absolute=yes
     8385      hardcode_libdir_separator=':'
     8386      link_all_deplibs=yes
     8387      file_list_spec='${wl}-f,'
     8388
     8389      if test "$GCC" = yes; then
     8390        case $host_os in aix4.[012]|aix4.[012].*)
     8391        # We only want to do this on AIX 4.2 and lower, the check
     8392        # below for broken collect2 doesn't work under 4.3+
     8393          collect2name=`${CC} -print-prog-name=collect2`
     8394          if test -f "$collect2name" &&
     8395           strings "$collect2name" | $GREP resolve_lib_name >/dev/null
     8396          then
     8397          # We have reworked collect2
     8398          :
     8399          else
     8400          # We have old collect2
     8401          hardcode_direct=unsupported
     8402          # It fails to find uninstalled libraries when the uninstalled
     8403          # path is not listed in the libpath.  Setting hardcode_minus_L
     8404          # to unsupported forces relinking
     8405          hardcode_minus_L=yes
     8406          hardcode_libdir_flag_spec='-L$libdir'
     8407          hardcode_libdir_separator=
     8408          fi
     8409          ;;
     8410        esac
     8411        shared_flag='-shared'
     8412        if test "$aix_use_runtimelinking" = yes; then
     8413          shared_flag="$shared_flag "'${wl}-G'
     8414        fi
     8415        link_all_deplibs=no
     8416      else
     8417        # not using gcc
     8418        if test "$host_cpu" = ia64; then
     8419        # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
     8420        # chokes on -Wl,-G. The following line is correct:
     8421          shared_flag='-G'
     8422        else
     8423          if test "$aix_use_runtimelinking" = yes; then
     8424            shared_flag='${wl}-G'
     8425          else
     8426            shared_flag='${wl}-bM:SRE'
     8427          fi
     8428        fi
     8429      fi
     8430
     8431      # It seems that -bexpall does not export symbols beginning with
     8432      # underscore (_), so it is better to generate a list of symbols to export.
     8433      always_export_symbols=yes
     8434      if test "$aix_use_runtimelinking" = yes; then
     8435        # Warning - without using the other runtime loading flags (-brtl),
     8436        # -berok will link without error, but may produce a broken library.
     8437        allow_undefined_flag='-berok'
     8438        # Determine the default libpath from the value encoded in an
     8439        # empty executable.
     8440        cat >conftest.$ac_ext <<_ACEOF
    74318441/* confdefs.h.  */
    74328442_ACEOF
     
    74618471       } && test -s conftest$ac_exeext &&
    74628472       $as_test_x conftest$ac_exeext; then
    7463   lt_cv_ld_exported_symbols_list=yes
     8473
     8474lt_aix_libpath_sed='
     8475    /Import File Strings/,/^$/ {
     8476        /^0/ {
     8477            s/^0  *\(.*\)$/\1/
     8478            p
     8479        }
     8480    }'
     8481aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
     8482# Check for a 64-bit object if we didn't find anything.
     8483if test -z "$aix_libpath"; then
     8484  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
     8485fi
    74648486else
    74658487  echo "$as_me: failed program was:" >&5
    74668488sed 's/^/| /' conftest.$ac_ext >&5
    74678489
    7468         lt_cv_ld_exported_symbols_list=no
     8490
    74698491fi
    74708492
    74718493rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
    74728494      conftest$ac_exeext conftest.$ac_ext
    7473    LDFLAGS="$save_LDFLAGS"
    7474 
    7475 fi
    7476 { echo "$as_me:$LINENO: result: $lt_cv_ld_exported_symbols_list" >&5
    7477 echo "${ECHO_T}$lt_cv_ld_exported_symbols_list" >&6; }
    7478     case $host_os in
    7479     rhapsody* | darwin1.[0123])
    7480       _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
    7481     darwin1.*)
    7482      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
    7483     darwin*)
    7484       # if running on 10.5 or later, the deployment target defaults
    7485       # to the OS version, if on x86, and 10.4, the deployment
    7486       # target defaults to 10.4. Don't you love it?
    7487       case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
    7488    10.0,*86*-darwin8*|10.0,*-darwin[91]*)
    7489      _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
    7490    10.[012]*)
    7491      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
    7492    10.*)
    7493      _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
    7494       esac
    7495     ;;
    7496   esac
    7497     if test "$lt_cv_apple_cc_single_mod" = "yes"; then
    7498       _lt_dar_single_mod='$single_module'
    7499     fi
    7500     if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
    7501       _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
    7502     else
    7503       _lt_dar_export_syms="~$NMEDIT -s \$output_objdir/\${libname}-symbols.expsym \${lib}"
    7504     fi
    7505     if test "$DSYMUTIL" != ":"; then
    7506       _lt_dsymutil="~$DSYMUTIL \$lib || :"
    7507     else
    7508       _lt_dsymutil=
    7509     fi
    7510     ;;
    7511   esac
    7512 
    7513 
    7514 enable_dlopen=no
    7515 enable_win32_dll=no
    7516 
    7517 # Check whether --enable-libtool-lock was given.
    7518 if test "${enable_libtool_lock+set}" = set; then
    7519   enableval=$enable_libtool_lock;
    7520 fi
    7521 
    7522 test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
    7523 
    7524 
    7525 # Check whether --with-pic was given.
    7526 if test "${with_pic+set}" = set; then
    7527   withval=$with_pic; pic_mode="$withval"
    7528 else
    7529   pic_mode=default
    7530 fi
    7531 
    7532 test -z "$pic_mode" && pic_mode=default
    7533 
    7534 # Use C for the default configuration in the libtool script
    7535 tagname=
    7536 lt_save_CC="$CC"
    7537 ac_ext=c
    7538 ac_cpp='$CPP $CPPFLAGS'
    7539 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    7540 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    7541 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    7542 
    7543 
    7544 # Source file extension for C test sources.
    7545 ac_ext=c
    7546 
    7547 # Object file extension for compiled C test sources.
    7548 objext=o
    7549 objext=$objext
    7550 
    7551 # Code to be used in simple compile tests
    7552 lt_simple_compile_test_code="int some_variable = 0;"
    7553 
    7554 # Code to be used in simple link tests
    7555 lt_simple_link_test_code='int main(){return(0);}'
    7556 
    7557 
    7558 # If no C compiler was specified, use CC.
    7559 LTCC=${LTCC-"$CC"}
    7560 
    7561 # If no C compiler flags were specified, use CFLAGS.
    7562 LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
    7563 
    7564 # Allow CC to be a program name with arguments.
    7565 compiler=$CC
    7566 
    7567 
    7568 # save warnings/boilerplate of simple test code
    7569 ac_outfile=conftest.$ac_objext
    7570 echo "$lt_simple_compile_test_code" >conftest.$ac_ext
    7571 eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
    7572 _lt_compiler_boilerplate=`cat conftest.err`
    7573 $rm conftest*
    7574 
    7575 ac_outfile=conftest.$ac_objext
    7576 echo "$lt_simple_link_test_code" >conftest.$ac_ext
    7577 eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
    7578 _lt_linker_boilerplate=`cat conftest.err`
    7579 $rm -r conftest*
    7580 
    7581 
    7582 
    7583 lt_prog_compiler_no_builtin_flag=
    7584 
    7585 if test "$GCC" = yes; then
    7586   lt_prog_compiler_no_builtin_flag=' -fno-builtin'
    7587 
    7588 
    7589 { echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
    7590 echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6; }
    7591 if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
    7592   echo $ECHO_N "(cached) $ECHO_C" >&6
    7593 else
    7594   lt_cv_prog_compiler_rtti_exceptions=no
    7595   ac_outfile=conftest.$ac_objext
    7596    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    7597    lt_compiler_flag="-fno-rtti -fno-exceptions"
    7598    # Insert the option either (1) after the last *FLAGS variable, or
    7599    # (2) before a word containing "conftest.", or (3) at the end.
    7600    # Note that $ac_compile itself does not contain backslashes and begins
    7601    # with a dollar sign (not a hyphen), so the echo should work correctly.
    7602    # The option is referenced via a variable to avoid confusing sed.
    7603    lt_compile=`echo "$ac_compile" | $SED \
    7604    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    7605    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    7606    -e 's:$: $lt_compiler_flag:'`
    7607    (eval echo "\"\$as_me:7607: $lt_compile\"" >&5)
    7608    (eval "$lt_compile" 2>conftest.err)
    7609    ac_status=$?
    7610    cat conftest.err >&5
    7611    echo "$as_me:7611: \$? = $ac_status" >&5
    7612    if (exit $ac_status) && test -s "$ac_outfile"; then
    7613      # The compiler can only warn and ignore the option if not recognized
    7614      # So say no if there are warnings other than the usual output.
    7615      $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
    7616      $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
    7617      if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
    7618        lt_cv_prog_compiler_rtti_exceptions=yes
    7619      fi
    7620    fi
    7621    $rm conftest*
    7622 
    7623 fi
    7624 { echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
    7625 echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6; }
    7626 
    7627 if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
    7628     lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
    7629 else
    7630     :
    7631 fi
    7632 
    7633 fi
    7634 
    7635 lt_prog_compiler_wl=
    7636 lt_prog_compiler_pic=
    7637 lt_prog_compiler_static=
    7638 
    7639 { echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
    7640 echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6; }
    7641 
    7642   if test "$GCC" = yes; then
    7643     lt_prog_compiler_wl='-Wl,'
    7644     lt_prog_compiler_static='-static'
    7645 
    7646     case $host_os in
    7647       aix*)
    7648       # All AIX code is PIC.
    7649       if test "$host_cpu" = ia64; then
    7650         # AIX 5 now supports IA64 processor
    7651         lt_prog_compiler_static='-Bstatic'
    7652       fi
    7653       ;;
    7654 
    7655     amigaos*)
    7656       # FIXME: we need at least 68020 code to build shared libraries, but
    7657       # adding the `-m68020' flag to GCC prevents building anything better,
    7658       # like `-m68040'.
    7659       lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
    7660       ;;
    7661 
    7662     beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
    7663       # PIC is the default for these OSes.
    7664       ;;
    7665 
    7666     mingw* | cygwin* | pw32* | os2*)
    7667       # This hack is so that the source file can tell whether it is being
    7668       # built for inclusion in a dll (and should export symbols for example).
    7669       # Although the cygwin gcc ignores -fPIC, still need this for old-style
    7670       # (--disable-auto-import) libraries
    7671       lt_prog_compiler_pic='-DDLL_EXPORT'
    7672       ;;
    7673 
    7674     darwin* | rhapsody*)
    7675       # PIC is the default on this platform
    7676       # Common symbols not allowed in MH_DYLIB files
    7677       lt_prog_compiler_pic='-fno-common'
    7678       ;;
    7679 
    7680     interix[3-9]*)
    7681       # Interix 3.x gcc -fpic/-fPIC options generate broken code.
    7682       # Instead, we relocate shared libraries at runtime.
    7683       ;;
    7684 
    7685     msdosdjgpp*)
    7686       # Just because we use GCC doesn't mean we suddenly get shared libraries
    7687       # on systems that don't support them.
    7688       lt_prog_compiler_can_build_shared=no
    7689       enable_shared=no
    7690       ;;
    7691 
    7692     sysv4*MP*)
    7693       if test -d /usr/nec; then
    7694         lt_prog_compiler_pic=-Kconform_pic
    7695       fi
    7696       ;;
    7697 
    7698     hpux*)
    7699       # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
    7700       # not for PA HP-UX.
    7701       case $host_cpu in
    7702       hppa*64*|ia64*)
    7703         # +Z the default
    7704         ;;
    7705       *)
    7706         lt_prog_compiler_pic='-fPIC'
    7707         ;;
    7708       esac
    7709       ;;
    7710 
    7711     *)
    7712       lt_prog_compiler_pic='-fPIC'
    7713       ;;
    7714     esac
    7715   else
    7716     # PORTME Check for flag to pass linker flags through the system compiler.
    7717     case $host_os in
    7718     aix*)
    7719       lt_prog_compiler_wl='-Wl,'
    7720       if test "$host_cpu" = ia64; then
    7721         # AIX 5 now supports IA64 processor
    7722         lt_prog_compiler_static='-Bstatic'
     8495if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
     8496
     8497        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
     8498        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
    77238499      else
    7724         lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
    7725       fi
    7726       ;;
    7727       darwin*)
    7728         # PIC is the default on this platform
    7729         # Common symbols not allowed in MH_DYLIB files
    7730        case $cc_basename in
    7731          xlc*)
    7732          lt_prog_compiler_pic='-qnocommon'
    7733          lt_prog_compiler_wl='-Wl,'
    7734          ;;
    7735        esac
    7736        ;;
    7737 
    7738     mingw* | cygwin* | pw32* | os2*)
    7739       # This hack is so that the source file can tell whether it is being
    7740       # built for inclusion in a dll (and should export symbols for example).
    7741       lt_prog_compiler_pic='-DDLL_EXPORT'
    7742       ;;
    7743 
    7744     hpux9* | hpux10* | hpux11*)
    7745       lt_prog_compiler_wl='-Wl,'
    7746       # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
    7747       # not for PA HP-UX.
    7748       case $host_cpu in
    7749       hppa*64*|ia64*)
    7750         # +Z the default
    7751         ;;
    7752       *)
    7753         lt_prog_compiler_pic='+Z'
    7754         ;;
    7755       esac
    7756       # Is there a better lt_prog_compiler_static that works with the bundled CC?
    7757       lt_prog_compiler_static='${wl}-a ${wl}archive'
    7758       ;;
    7759 
    7760     irix5* | irix6* | nonstopux*)
    7761       lt_prog_compiler_wl='-Wl,'
    7762       # PIC (with -KPIC) is the default.
    7763       lt_prog_compiler_static='-non_shared'
    7764       ;;
    7765 
    7766     newsos6)
    7767       lt_prog_compiler_pic='-KPIC'
    7768       lt_prog_compiler_static='-Bstatic'
    7769       ;;
    7770 
    7771     linux* | k*bsd*-gnu)
    7772       case $cc_basename in
    7773       icc* | ecc*)
    7774         lt_prog_compiler_wl='-Wl,'
    7775         lt_prog_compiler_pic='-KPIC'
    7776         lt_prog_compiler_static='-static'
    7777         ;;
    7778       pgcc* | pgf77* | pgf90* | pgf95*)
    7779         # Portland Group compilers (*not* the Pentium gcc compiler,
    7780         # which looks to be a dead project)
    7781         lt_prog_compiler_wl='-Wl,'
    7782         lt_prog_compiler_pic='-fpic'
    7783         lt_prog_compiler_static='-Bstatic'
    7784         ;;
    7785       ccc*)
    7786         lt_prog_compiler_wl='-Wl,'
    7787         # All Alpha code is PIC.
    7788         lt_prog_compiler_static='-non_shared'
    7789         ;;
    7790       *)
    7791         case `$CC -V 2>&1 | sed 5q` in
    7792         *Sun\ C*)
    7793           # Sun C 5.9
    7794           lt_prog_compiler_pic='-KPIC'
    7795           lt_prog_compiler_static='-Bstatic'
    7796           lt_prog_compiler_wl='-Wl,'
    7797           ;;
    7798         *Sun\ F*)
    7799           # Sun Fortran 8.3 passes all unrecognized flags to the linker
    7800           lt_prog_compiler_pic='-KPIC'
    7801           lt_prog_compiler_static='-Bstatic'
    7802           lt_prog_compiler_wl=''
    7803           ;;
    7804         esac
    7805         ;;
    7806       esac
    7807       ;;
    7808 
    7809     osf3* | osf4* | osf5*)
    7810       lt_prog_compiler_wl='-Wl,'
    7811       # All OSF/1 code is PIC.
    7812       lt_prog_compiler_static='-non_shared'
    7813       ;;
    7814 
    7815     rdos*)
    7816       lt_prog_compiler_static='-non_shared'
    7817       ;;
    7818 
    7819     solaris*)
    7820       lt_prog_compiler_pic='-KPIC'
    7821       lt_prog_compiler_static='-Bstatic'
    7822       case $cc_basename in
    7823       f77* | f90* | f95*)
    7824         lt_prog_compiler_wl='-Qoption ld ';;
    7825       *)
    7826         lt_prog_compiler_wl='-Wl,';;
    7827       esac
    7828       ;;
    7829 
    7830     sunos4*)
    7831       lt_prog_compiler_wl='-Qoption ld '
    7832       lt_prog_compiler_pic='-PIC'
    7833       lt_prog_compiler_static='-Bstatic'
    7834       ;;
    7835 
    7836     sysv4 | sysv4.2uw2* | sysv4.3*)
    7837       lt_prog_compiler_wl='-Wl,'
    7838       lt_prog_compiler_pic='-KPIC'
    7839       lt_prog_compiler_static='-Bstatic'
    7840       ;;
    7841 
    7842     sysv4*MP*)
    7843       if test -d /usr/nec ;then
    7844         lt_prog_compiler_pic='-Kconform_pic'
    7845         lt_prog_compiler_static='-Bstatic'
    7846       fi
    7847       ;;
    7848 
    7849     sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
    7850       lt_prog_compiler_wl='-Wl,'
    7851       lt_prog_compiler_pic='-KPIC'
    7852       lt_prog_compiler_static='-Bstatic'
    7853       ;;
    7854 
    7855     unicos*)
    7856       lt_prog_compiler_wl='-Wl,'
    7857       lt_prog_compiler_can_build_shared=no
    7858       ;;
    7859 
    7860     uts4*)
    7861       lt_prog_compiler_pic='-pic'
    7862       lt_prog_compiler_static='-Bstatic'
    7863       ;;
    7864 
    7865     *)
    7866       lt_prog_compiler_can_build_shared=no
    7867       ;;
    7868     esac
    7869   fi
    7870 
    7871 { echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5
    7872 echo "${ECHO_T}$lt_prog_compiler_pic" >&6; }
    7873 
    7874 #
    7875 # Check to make sure the PIC flag actually works.
    7876 #
    7877 if test -n "$lt_prog_compiler_pic"; then
    7878 
    7879 { echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
    7880 echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic works... $ECHO_C" >&6; }
    7881 if test "${lt_cv_prog_compiler_pic_works+set}" = set; then
    7882   echo $ECHO_N "(cached) $ECHO_C" >&6
    7883 else
    7884   lt_cv_prog_compiler_pic_works=no
    7885   ac_outfile=conftest.$ac_objext
    7886    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    7887    lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
    7888    # Insert the option either (1) after the last *FLAGS variable, or
    7889    # (2) before a word containing "conftest.", or (3) at the end.
    7890    # Note that $ac_compile itself does not contain backslashes and begins
    7891    # with a dollar sign (not a hyphen), so the echo should work correctly.
    7892    # The option is referenced via a variable to avoid confusing sed.
    7893    lt_compile=`echo "$ac_compile" | $SED \
    7894    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    7895    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    7896    -e 's:$: $lt_compiler_flag:'`
    7897    (eval echo "\"\$as_me:7897: $lt_compile\"" >&5)
    7898    (eval "$lt_compile" 2>conftest.err)
    7899    ac_status=$?
    7900    cat conftest.err >&5
    7901    echo "$as_me:7901: \$? = $ac_status" >&5
    7902    if (exit $ac_status) && test -s "$ac_outfile"; then
    7903      # The compiler can only warn and ignore the option if not recognized
    7904      # So say no if there are warnings other than the usual output.
    7905      $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
    7906      $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
    7907      if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
    7908        lt_cv_prog_compiler_pic_works=yes
    7909      fi
    7910    fi
    7911    $rm conftest*
    7912 
    7913 fi
    7914 { echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_pic_works" >&5
    7915 echo "${ECHO_T}$lt_cv_prog_compiler_pic_works" >&6; }
    7916 
    7917 if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
    7918     case $lt_prog_compiler_pic in
    7919      "" | " "*) ;;
    7920      *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
    7921      esac
    7922 else
    7923     lt_prog_compiler_pic=
    7924      lt_prog_compiler_can_build_shared=no
    7925 fi
    7926 
    7927 fi
    7928 case $host_os in
    7929   # For platforms which do not support PIC, -DPIC is meaningless:
    7930   *djgpp*)
    7931     lt_prog_compiler_pic=
    7932     ;;
    7933   *)
    7934     lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
    7935     ;;
    7936 esac
    7937 
    7938 #
    7939 # Check to make sure the static flag actually works.
    7940 #
    7941 wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
    7942 { echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
    7943 echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6; }
    7944 if test "${lt_cv_prog_compiler_static_works+set}" = set; then
    7945   echo $ECHO_N "(cached) $ECHO_C" >&6
    7946 else
    7947   lt_cv_prog_compiler_static_works=no
    7948    save_LDFLAGS="$LDFLAGS"
    7949    LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
    7950    echo "$lt_simple_link_test_code" > conftest.$ac_ext
    7951    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
    7952      # The linker can only warn and ignore the option if not recognized
    7953      # So say no if there are warnings
    7954      if test -s conftest.err; then
    7955        # Append any errors to the config.log.
    7956        cat conftest.err 1>&5
    7957        $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
    7958        $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
    7959        if diff conftest.exp conftest.er2 >/dev/null; then
    7960          lt_cv_prog_compiler_static_works=yes
    7961        fi
    7962      else
    7963        lt_cv_prog_compiler_static_works=yes
    7964      fi
    7965    fi
    7966    $rm -r conftest*
    7967    LDFLAGS="$save_LDFLAGS"
    7968 
    7969 fi
    7970 { echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_static_works" >&5
    7971 echo "${ECHO_T}$lt_cv_prog_compiler_static_works" >&6; }
    7972 
    7973 if test x"$lt_cv_prog_compiler_static_works" = xyes; then
    7974     :
    7975 else
    7976     lt_prog_compiler_static=
    7977 fi
    7978 
    7979 
    7980 { echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
    7981 echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6; }
    7982 if test "${lt_cv_prog_compiler_c_o+set}" = set; then
    7983   echo $ECHO_N "(cached) $ECHO_C" >&6
    7984 else
    7985   lt_cv_prog_compiler_c_o=no
    7986    $rm -r conftest 2>/dev/null
    7987    mkdir conftest
    7988    cd conftest
    7989    mkdir out
    7990    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    7991 
    7992    lt_compiler_flag="-o out/conftest2.$ac_objext"
    7993    # Insert the option either (1) after the last *FLAGS variable, or
    7994    # (2) before a word containing "conftest.", or (3) at the end.
    7995    # Note that $ac_compile itself does not contain backslashes and begins
    7996    # with a dollar sign (not a hyphen), so the echo should work correctly.
    7997    lt_compile=`echo "$ac_compile" | $SED \
    7998    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    7999    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    8000    -e 's:$: $lt_compiler_flag:'`
    8001    (eval echo "\"\$as_me:8001: $lt_compile\"" >&5)
    8002    (eval "$lt_compile" 2>out/conftest.err)
    8003    ac_status=$?
    8004    cat out/conftest.err >&5
    8005    echo "$as_me:8005: \$? = $ac_status" >&5
    8006    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    8007    then
    8008      # The compiler can only warn and ignore the option if not recognized
    8009      # So say no if there are warnings
    8010      $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
    8011      $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
    8012      if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
    8013        lt_cv_prog_compiler_c_o=yes
    8014      fi
    8015    fi
    8016    chmod u+w . 2>&5
    8017    $rm conftest*
    8018    # SGI C++ compiler will create directory out/ii_files/ for
    8019    # template instantiation
    8020    test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
    8021    $rm out/* && rmdir out
    8022    cd ..
    8023    rmdir conftest
    8024    $rm conftest*
    8025 
    8026 fi
    8027 { echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
    8028 echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6; }
    8029 
    8030 
    8031 hard_links="nottested"
    8032 if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
    8033   # do not overwrite the value of need_locks provided by the user
    8034   { echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
    8035 echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6; }
    8036   hard_links=yes
    8037   $rm conftest*
    8038   ln conftest.a conftest.b 2>/dev/null && hard_links=no
    8039   touch conftest.a
    8040   ln conftest.a conftest.b 2>&5 || hard_links=no
    8041   ln conftest.a conftest.b 2>/dev/null && hard_links=no
    8042   { echo "$as_me:$LINENO: result: $hard_links" >&5
    8043 echo "${ECHO_T}$hard_links" >&6; }
    8044   if test "$hard_links" = no; then
    8045     { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
    8046 echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
    8047     need_locks=warn
    8048   fi
    8049 else
    8050   need_locks=no
    8051 fi
    8052 
    8053 { echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
    8054 echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6; }
    8055 
    8056   runpath_var=
    8057   allow_undefined_flag=
    8058   enable_shared_with_static_runtimes=no
    8059   archive_cmds=
    8060   archive_expsym_cmds=
    8061   old_archive_From_new_cmds=
    8062   old_archive_from_expsyms_cmds=
    8063   export_dynamic_flag_spec=
    8064   whole_archive_flag_spec=
    8065   thread_safe_flag_spec=
    8066   hardcode_libdir_flag_spec=
    8067   hardcode_libdir_flag_spec_ld=
    8068   hardcode_libdir_separator=
    8069   hardcode_direct=no
    8070   hardcode_minus_L=no
    8071   hardcode_shlibpath_var=unsupported
    8072   link_all_deplibs=unknown
    8073   hardcode_automatic=no
    8074   module_cmds=
    8075   module_expsym_cmds=
    8076   always_export_symbols=no
    8077   export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
    8078   # include_expsyms should be a list of space-separated symbols to be *always*
    8079   # included in the symbol list
    8080   include_expsyms=
    8081   # exclude_expsyms can be an extended regexp of symbols to exclude
    8082   # it will be wrapped by ` (' and `)$', so one must not match beginning or
    8083   # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
    8084   # as well as any symbol that contains `d'.
    8085   exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
    8086   # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
    8087   # platforms (ab)use it in PIC code, but their linkers get confused if
    8088   # the symbol is explicitly referenced.  Since portable code cannot
    8089   # rely on this symbol name, it's probably fine to never include it in
    8090   # preloaded symbol tables.
    8091   # Exclude shared library initialization/finalization symbols.
    8092   extract_expsyms_cmds=
    8093   # Just being paranoid about ensuring that cc_basename is set.
    8094   for cc_temp in $compiler""; do
    8095   case $cc_temp in
    8096     compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
    8097     distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
    8098     \-*) ;;
    8099     *) break;;
    8100   esac
    8101 done
    8102 cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
    8103 
    8104   case $host_os in
    8105   cygwin* | mingw* | pw32*)
    8106     # FIXME: the MSVC++ port hasn't been tested in a loooong time
    8107     # When not using gcc, we currently assume that we are using
    8108     # Microsoft Visual C++.
    8109     if test "$GCC" != yes; then
    8110       with_gnu_ld=no
    8111     fi
    8112     ;;
    8113   interix*)
    8114     # we just hope/assume this is gcc and not c89 (= MSVC++)
    8115     with_gnu_ld=yes
    8116     ;;
    8117   openbsd*)
    8118     with_gnu_ld=no
    8119     ;;
    8120   esac
    8121 
    8122   ld_shlibs=yes
    8123   if test "$with_gnu_ld" = yes; then
    8124     # If archive_cmds runs LD, not CC, wlarc should be empty
    8125     wlarc='${wl}'
    8126 
    8127     # Set some defaults for GNU ld with shared library support. These
    8128     # are reset later if shared libraries are not supported. Putting them
    8129     # here allows them to be overridden if necessary.
    8130     runpath_var=LD_RUN_PATH
    8131     hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir'
    8132     export_dynamic_flag_spec='${wl}--export-dynamic'
    8133     # ancient GNU ld didn't support --whole-archive et. al.
    8134     if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
    8135         whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
    8136       else
    8137         whole_archive_flag_spec=
    8138     fi
    8139     supports_anon_versioning=no
    8140     case `$LD -v 2>/dev/null` in
    8141       *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
    8142       *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
    8143       *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
    8144       *\ 2.11.*) ;; # other 2.11 versions
    8145       *) supports_anon_versioning=yes ;;
    8146     esac
    8147 
    8148     # See if GNU ld supports shared libraries.
    8149     case $host_os in
    8150     aix[3-9]*)
    8151       # On AIX/PPC, the GNU linker is very broken
    8152       if test "$host_cpu" != ia64; then
    8153         ld_shlibs=no
    8154         cat <<EOF 1>&2
    8155 
    8156 *** Warning: the GNU linker, at least up to release 2.9.1, is reported
    8157 *** to be unable to reliably create shared libraries on AIX.
    8158 *** Therefore, libtool is disabling shared libraries support.  If you
    8159 *** really care for shared libraries, you may want to modify your PATH
    8160 *** so that a non-GNU linker is found, and then restart.
    8161 
    8162 EOF
    8163       fi
    8164       ;;
    8165 
    8166     amigaos*)
    8167       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)'
    8168       hardcode_libdir_flag_spec='-L$libdir'
    8169       hardcode_minus_L=yes
    8170 
    8171       # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
    8172       # that the semantics of dynamic libraries on AmigaOS, at least up
    8173       # to version 4, is to share data among multiple programs linked
    8174       # with the same dynamic library.  Since this doesn't match the
    8175       # behavior of shared libraries on other platforms, we can't use
    8176       # them.
    8177       ld_shlibs=no
    8178       ;;
    8179 
    8180     beos*)
    8181       if $LD --help 2&