Changeset 915 for trunk/configure


Ignore:
Timestamp:
Feb 1, 2007 3:15:10 PM (14 years ago)
Author:
andreasw
Message:

reran autotools with latest coin.m4 in trunk; replaced make by $(MAKE); set all externals to trunk

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

    • Property svn:externals
      •  

        old new  
        11MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/trunk/ExternalsDirs/Clp
        2 BuildTools    https://projects.coin-or.org/svn/BuildTools/stable/0.5
        3 Data/Netlib   https://projects.coin-or.org/svn/Data/stable/1.0/Netlib
        4 Data/Sample   https://projects.coin-or.org/svn/Data/stable/1.0/Sample
         2BuildTools    https://projects.coin-or.org/svn/BuildTools/trunk
         3Data/Netlib   https://projects.coin-or.org/svn/Data/trunk/Netlib
         4Data/Sample   https://projects.coin-or.org/svn/Data/trunk/Sample
        55CoinUtils     https://projects.coin-or.org/svn/CoinUtils/trunk/CoinUtils
  • trunk/configure

    r818 r915  
    251251
    252252
     253
     254# Check that we are running under the correct shell.
     255SHELL=${CONFIG_SHELL-/bin/sh}
     256
     257case X$ECHO in
     258X*--fallback-echo)
     259  # Remove one level of quotation (which was required for Make).
     260  ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','`
     261  ;;
     262esac
     263
     264echo=${ECHO-echo}
     265if test "X$1" = X--no-reexec; then
     266  # Discard the --no-reexec flag, and continue.
     267  shift
     268elif test "X$1" = X--fallback-echo; then
     269  # Avoid inline document here, it may be left over
     270  :
     271elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
     272  # Yippee, $echo works!
     273  :
     274else
     275  # Restart under the correct shell.
     276  exec $SHELL "$0" --no-reexec ${1+"$@"}
     277fi
     278
     279if test "X$1" = X--fallback-echo; then
     280  # used as fallback echo
     281  shift
     282  cat <<EOF
     283$*
     284EOF
     285  exit 0
     286fi
     287
     288# The HP-UX ksh and POSIX shell print the target directory to stdout
     289# if CDPATH is set.
     290(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
     291
     292if test -z "$ECHO"; then
     293if test "X${echo_test_string+set}" != Xset; then
     294# find a string as large as possible, as long as the shell can cope with it
     295  for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do
     296    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
     297    if (echo_test_string=`eval $cmd`) 2>/dev/null &&
     298       echo_test_string=`eval $cmd` &&
     299       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
     300    then
     301      break
     302    fi
     303  done
     304fi
     305
     306if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
     307   echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
     308   test "X$echo_testing_string" = "X$echo_test_string"; then
     309  :
     310else
     311  # The Solaris, AIX, and Digital Unix default echo programs unquote
     312  # backslashes.  This makes it impossible to quote backslashes using
     313  #   echo "$something" | sed 's/\\/\\\\/g'
     314  #
     315  # So, first we look for a working echo in the user's PATH.
     316
     317  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     318  for dir in $PATH /usr/ucb; do
     319    IFS="$lt_save_ifs"
     320    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
     321       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
     322       echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
     323       test "X$echo_testing_string" = "X$echo_test_string"; then
     324      echo="$dir/echo"
     325      break
     326    fi
     327  done
     328  IFS="$lt_save_ifs"
     329
     330  if test "X$echo" = Xecho; then
     331    # We didn't find a better echo, so look for alternatives.
     332    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
     333       echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
     334       test "X$echo_testing_string" = "X$echo_test_string"; then
     335      # This shell has a builtin print -r that does the trick.
     336      echo='print -r'
     337    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
     338         test "X$CONFIG_SHELL" != X/bin/ksh; then
     339      # If we have ksh, try running configure again with it.
     340      ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
     341      export ORIGINAL_CONFIG_SHELL
     342      CONFIG_SHELL=/bin/ksh
     343      export CONFIG_SHELL
     344      exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"}
     345    else
     346      # Try using printf.
     347      echo='printf %s\n'
     348      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
     349         echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
     350         test "X$echo_testing_string" = "X$echo_test_string"; then
     351        # Cool, printf works
     352        :
     353      elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
     354           test "X$echo_testing_string" = 'X\t' &&
     355           echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
     356           test "X$echo_testing_string" = "X$echo_test_string"; then
     357        CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
     358        export CONFIG_SHELL
     359        SHELL="$CONFIG_SHELL"
     360        export SHELL
     361        echo="$CONFIG_SHELL $0 --fallback-echo"
     362      elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
     363           test "X$echo_testing_string" = 'X\t' &&
     364           echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
     365           test "X$echo_testing_string" = "X$echo_test_string"; then
     366        echo="$CONFIG_SHELL $0 --fallback-echo"
     367      else
     368        # maybe with a smaller string...
     369        prev=:
     370
     371        for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do
     372          if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
     373          then
     374            break
     375          fi
     376          prev="$cmd"
     377        done
     378
     379        if test "$prev" != 'sed 50q "$0"'; then
     380          echo_test_string=`eval $prev`
     381          export echo_test_string
     382          exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"}
     383        else
     384          # Oops.  We lost completely, so just stick with echo.
     385          echo=echo
     386        fi
     387      fi
     388    fi
     389  fi
     390fi
     391fi
     392
     393# Copy echo and quote the copy suitably for passing to libtool from
     394# the Makefile, instead of quoting the original, which is used later.
     395ECHO=$echo
     396if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then
     397   ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"
     398fi
     399
     400
     401
     402
     403tagnames=${tagnames+${tagnames},}CXX
     404
     405tagnames=${tagnames+${tagnames},}F77
     406
    253407# Name of the host.
    254408# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
     
    283437ac_unique_file="configure.ac"
    284438ac_default_prefix=`pwd`
     439# Factoring default headers for most tests.
     440ac_includes_default="\
     441#include <stdio.h>
     442#if HAVE_SYS_TYPES_H
     443# include <sys/types.h>
     444#endif
     445#if HAVE_SYS_STAT_H
     446# include <sys/stat.h>
     447#endif
     448#if STDC_HEADERS
     449# include <stdlib.h>
     450# include <stddef.h>
     451#else
     452# if HAVE_STDLIB_H
     453#  include <stdlib.h>
     454# endif
     455#endif
     456#if HAVE_STRING_H
     457# if !STDC_HEADERS && HAVE_MEMORY_H
     458#  include <memory.h>
     459# endif
     460# include <string.h>
     461#endif
     462#if HAVE_STRINGS_H
     463# include <strings.h>
     464#endif
     465#if HAVE_INTTYPES_H
     466# include <inttypes.h>
     467#else
     468# if HAVE_STDINT_H
     469#  include <stdint.h>
     470# endif
     471#endif
     472#if HAVE_UNISTD_H
     473# include <unistd.h>
     474#endif"
     475
    285476ac_subdirs_all="$ac_subdirs_all CoinUtils"
    286477ac_subdirs_all="$ac_subdirs_all Data/Netlib"
    287478ac_subdirs_all="$ac_subdirs_all Data/Sample"
    288479ac_subdirs_all="$ac_subdirs_all Clp"
    289 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS EGREP INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT LIBTOOLM4 have_autoconf have_automake have_svn BUILDTOOLSDIR AUX_DIR abs_source_dir abs_lib_dir abs_include_dir abs_bin_dir HAVE_EXTERNALS_TRUE HAVE_EXTERNALS_FALSE COIN_SKIP_PROJECTS subdirs LIBOBJS LTLIBOBJS VPATH_DISTCLEANFILES'
     480ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os CDEFS ADD_CFLAGS DBG_CFLAGS OPT_CFLAGS CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT MPICC CXXDEFS ADD_CXXFLAGS DBG_CXXFLAGS OPT_CXXFLAGS CXX CXXFLAGS ac_ct_CXX MPICXX ADD_FFLAGS DBG_FFLAGS OPT_FFLAGS F77 FFLAGS ac_ct_F77 MPIF77 EGREP INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE CXXDEPMODE am__fastdepCXX_TRUE am__fastdepCXX_FALSE MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT LIBTOOLM4 have_autoconf have_automake have_svn BUILDTOOLSDIR AUX_DIR abs_source_dir abs_lib_dir abs_include_dir abs_bin_dir HAVE_EXTERNALS_TRUE HAVE_EXTERNALS_FALSE host host_cpu host_vendor host_os LN_S ECHO AR ac_ct_AR RANLIB ac_ct_RANLIB CPP CXXCPP LIBTOOL ac_c_preproc_warn_flag ac_cxx_preproc_warn_flag RPATH_FLAGS LT_LDFLAGS COIN_SKIP_PROJECTS subdirs LIBEXT VPATH_DISTCLEANFILES LIBOBJS LTLIBOBJS'
    290481ac_subst_files=''
    291482
     
    728919ac_cv_env_target_alias_set=${target_alias+set}
    729920ac_cv_env_target_alias_value=$target_alias
     921ac_env_CDEFS_set=${CDEFS+set}
     922ac_env_CDEFS_value=$CDEFS
     923ac_cv_env_CDEFS_set=${CDEFS+set}
     924ac_cv_env_CDEFS_value=$CDEFS
     925ac_env_ADD_CFLAGS_set=${ADD_CFLAGS+set}
     926ac_env_ADD_CFLAGS_value=$ADD_CFLAGS
     927ac_cv_env_ADD_CFLAGS_set=${ADD_CFLAGS+set}
     928ac_cv_env_ADD_CFLAGS_value=$ADD_CFLAGS
     929ac_env_DBG_CFLAGS_set=${DBG_CFLAGS+set}
     930ac_env_DBG_CFLAGS_value=$DBG_CFLAGS
     931ac_cv_env_DBG_CFLAGS_set=${DBG_CFLAGS+set}
     932ac_cv_env_DBG_CFLAGS_value=$DBG_CFLAGS
     933ac_env_OPT_CFLAGS_set=${OPT_CFLAGS+set}
     934ac_env_OPT_CFLAGS_value=$OPT_CFLAGS
     935ac_cv_env_OPT_CFLAGS_set=${OPT_CFLAGS+set}
     936ac_cv_env_OPT_CFLAGS_value=$OPT_CFLAGS
     937ac_env_CC_set=${CC+set}
     938ac_env_CC_value=$CC
     939ac_cv_env_CC_set=${CC+set}
     940ac_cv_env_CC_value=$CC
     941ac_env_CFLAGS_set=${CFLAGS+set}
     942ac_env_CFLAGS_value=$CFLAGS
     943ac_cv_env_CFLAGS_set=${CFLAGS+set}
     944ac_cv_env_CFLAGS_value=$CFLAGS
     945ac_env_LDFLAGS_set=${LDFLAGS+set}
     946ac_env_LDFLAGS_value=$LDFLAGS
     947ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
     948ac_cv_env_LDFLAGS_value=$LDFLAGS
     949ac_env_CPPFLAGS_set=${CPPFLAGS+set}
     950ac_env_CPPFLAGS_value=$CPPFLAGS
     951ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
     952ac_cv_env_CPPFLAGS_value=$CPPFLAGS
     953ac_env_MPICC_set=${MPICC+set}
     954ac_env_MPICC_value=$MPICC
     955ac_cv_env_MPICC_set=${MPICC+set}
     956ac_cv_env_MPICC_value=$MPICC
     957ac_env_CXXDEFS_set=${CXXDEFS+set}
     958ac_env_CXXDEFS_value=$CXXDEFS
     959ac_cv_env_CXXDEFS_set=${CXXDEFS+set}
     960ac_cv_env_CXXDEFS_value=$CXXDEFS
     961ac_env_ADD_CXXFLAGS_set=${ADD_CXXFLAGS+set}
     962ac_env_ADD_CXXFLAGS_value=$ADD_CXXFLAGS
     963ac_cv_env_ADD_CXXFLAGS_set=${ADD_CXXFLAGS+set}
     964ac_cv_env_ADD_CXXFLAGS_value=$ADD_CXXFLAGS
     965ac_env_DBG_CXXFLAGS_set=${DBG_CXXFLAGS+set}
     966ac_env_DBG_CXXFLAGS_value=$DBG_CXXFLAGS
     967ac_cv_env_DBG_CXXFLAGS_set=${DBG_CXXFLAGS+set}
     968ac_cv_env_DBG_CXXFLAGS_value=$DBG_CXXFLAGS
     969ac_env_OPT_CXXFLAGS_set=${OPT_CXXFLAGS+set}
     970ac_env_OPT_CXXFLAGS_value=$OPT_CXXFLAGS
     971ac_cv_env_OPT_CXXFLAGS_set=${OPT_CXXFLAGS+set}
     972ac_cv_env_OPT_CXXFLAGS_value=$OPT_CXXFLAGS
     973ac_env_CXX_set=${CXX+set}
     974ac_env_CXX_value=$CXX
     975ac_cv_env_CXX_set=${CXX+set}
     976ac_cv_env_CXX_value=$CXX
     977ac_env_CXXFLAGS_set=${CXXFLAGS+set}
     978ac_env_CXXFLAGS_value=$CXXFLAGS
     979ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
     980ac_cv_env_CXXFLAGS_value=$CXXFLAGS
     981ac_env_MPICXX_set=${MPICXX+set}
     982ac_env_MPICXX_value=$MPICXX
     983ac_cv_env_MPICXX_set=${MPICXX+set}
     984ac_cv_env_MPICXX_value=$MPICXX
     985ac_env_ADD_FFLAGS_set=${ADD_FFLAGS+set}
     986ac_env_ADD_FFLAGS_value=$ADD_FFLAGS
     987ac_cv_env_ADD_FFLAGS_set=${ADD_FFLAGS+set}
     988ac_cv_env_ADD_FFLAGS_value=$ADD_FFLAGS
     989ac_env_DBG_FFLAGS_set=${DBG_FFLAGS+set}
     990ac_env_DBG_FFLAGS_value=$DBG_FFLAGS
     991ac_cv_env_DBG_FFLAGS_set=${DBG_FFLAGS+set}
     992ac_cv_env_DBG_FFLAGS_value=$DBG_FFLAGS
     993ac_env_OPT_FFLAGS_set=${OPT_FFLAGS+set}
     994ac_env_OPT_FFLAGS_value=$OPT_FFLAGS
     995ac_cv_env_OPT_FFLAGS_set=${OPT_FFLAGS+set}
     996ac_cv_env_OPT_FFLAGS_value=$OPT_FFLAGS
     997ac_env_F77_set=${F77+set}
     998ac_env_F77_value=$F77
     999ac_cv_env_F77_set=${F77+set}
     1000ac_cv_env_F77_value=$F77
     1001ac_env_FFLAGS_set=${FFLAGS+set}
     1002ac_env_FFLAGS_value=$FFLAGS
     1003ac_cv_env_FFLAGS_set=${FFLAGS+set}
     1004ac_cv_env_FFLAGS_value=$FFLAGS
     1005ac_env_MPIF77_set=${MPIF77+set}
     1006ac_env_MPIF77_value=$MPIF77
     1007ac_cv_env_MPIF77_set=${MPIF77+set}
     1008ac_cv_env_MPIF77_value=$MPIF77
     1009ac_env_CPP_set=${CPP+set}
     1010ac_env_CPP_value=$CPP
     1011ac_cv_env_CPP_set=${CPP+set}
     1012ac_cv_env_CPP_value=$CPP
     1013ac_env_CXXCPP_set=${CXXCPP+set}
     1014ac_env_CXXCPP_value=$CXXCPP
     1015ac_cv_env_CXXCPP_set=${CXXCPP+set}
     1016ac_cv_env_CXXCPP_value=$CXXCPP
    7301017ac_env_COIN_SKIP_PROJECTS_set=${COIN_SKIP_PROJECTS+set}
    7311018ac_env_COIN_SKIP_PROJECTS_value=$COIN_SKIP_PROJECTS
     
    7971084  --program-suffix=SUFFIX            append SUFFIX to installed program names
    7981085  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
     1086
     1087System types:
     1088  --build=BUILD     configure for building on BUILD [guessed]
     1089  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
    7991090_ACEOF
    8001091fi
     
    8091100  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
    8101101  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
     1102  --enable-debug          compile all projects with debug options tests
     1103  --enable-doscompile     Under Cygwin, compile so that executables run under
     1104                          DOS. Set to mingw to use gcc/g++/ld with
     1105                          -mno-cygwin. Set to msvc to use cl/link. Default
     1106                          when mentioned: mingw. Default when not mentioned:
     1107                          disabled.
     1108  --enable-static[=PKGS]
     1109                          build static libraries [default=no]
     1110  --disable-dependency-tracking  speeds up one-time build
     1111  --enable-dependency-tracking   do not reject slow dependency extractors
    8111112  --enable-maintainer-mode  enable make rules and dependencies not useful
    8121113                          (and sometimes confusing) to the casual installer
     1114  --enable-shared[=PKGS]
     1115                          build shared libraries [default=yes]
     1116  --enable-fast-install[=PKGS]
     1117                          optimize for fast installation [default=yes]
     1118  --disable-libtool-lock  avoid locking (might break parallel builds)
     1119
     1120Optional Packages:
     1121  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
     1122  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
     1123  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
     1124  --with-pic              try to use only PIC/non-PIC objects [default=use
     1125                          both]
     1126  --with-tags[=TAGS]
     1127                          include additional configurations [automatic]
    8131128
    8141129Some influential environment variables:
     1130  CDEFS       Additional -D flags to be used when compiling C code.
     1131  ADD_CFLAGS  Additional C compiler options
     1132  DBG_CFLAGS  Debug C compiler options
     1133  OPT_CFLAGS  Optimize C compiler options
     1134  CC          C compiler command
     1135  CFLAGS      C compiler flags
     1136  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
     1137              nonstandard directory <lib dir>
     1138  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
     1139              headers in a nonstandard directory <include dir>
     1140  MPICC       C MPI Compiler
     1141  CXXDEFS     Additional -D flags to be used when compiling C++ code.
     1142  ADD_CXXFLAGS
     1143              Additional C++ compiler options
     1144  DBG_CXXFLAGS
     1145              Debug C++ compiler options
     1146  OPT_CXXFLAGS
     1147              Optimize C++ compiler options
     1148  CXX         C++ compiler command
     1149  CXXFLAGS    C++ compiler flags
     1150  MPICXX      C++ MPI Compiler
     1151  ADD_FFLAGS  Additional Fortran compiler options
     1152  DBG_FFLAGS  Debug Fortran compiler options
     1153  OPT_FFLAGS  Optimize Fortran compiler options
     1154  F77         Fortran 77 compiler command
     1155  FFLAGS      Fortran 77 compiler flags
     1156  MPIF77      Fortran MPI Compiler
     1157  CPP         C preprocessor
     1158  CXXCPP      C++ preprocessor
    8151159  COIN_SKIP_PROJECTS
    8161160              Set to the subdirectories of projects that should be skipped in
     
    12881632
    12891633#############################################################################
    1290 #     We only need automake to generate Makefiles for the distribution      #
     1634#              Create the libtool script for the subdirectories             #
    12911635#############################################################################
    12921636
    1293 # Initialize automake
    1294 echo "$as_me:$LINENO: checking for egrep" >&5
    1295 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
    1296 if test "${ac_cv_prog_egrep+set}" = set; then
    1297   echo $ECHO_N "(cached) $ECHO_C" >&6
    1298 else
    1299   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
    1300     then ac_cv_prog_egrep='grep -E'
    1301     else ac_cv_prog_egrep='egrep'
    1302     fi
    1303 fi
    1304 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
    1305 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
    1306  EGREP=$ac_cv_prog_egrep
    1307 
    1308 
    1309 am__api_version="1.9"
    13101637ac_aux_dir=
    13111638for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
     
    13331660ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
    13341661
     1662# Make sure we can run config.sub.
     1663$ac_config_sub sun4 >/dev/null 2>&1 ||
     1664  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
     1665echo "$as_me: error: cannot run $ac_config_sub" >&2;}
     1666   { (exit 1); exit 1; }; }
     1667
     1668echo "$as_me:$LINENO: checking build system type" >&5
     1669echo $ECHO_N "checking build system type... $ECHO_C" >&6
     1670if test "${ac_cv_build+set}" = set; then
     1671  echo $ECHO_N "(cached) $ECHO_C" >&6
     1672else
     1673  ac_cv_build_alias=$build_alias
     1674test -z "$ac_cv_build_alias" &&
     1675  ac_cv_build_alias=`$ac_config_guess`
     1676test -z "$ac_cv_build_alias" &&
     1677  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
     1678echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
     1679   { (exit 1); exit 1; }; }
     1680ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
     1681  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
     1682echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
     1683   { (exit 1); exit 1; }; }
     1684
     1685fi
     1686echo "$as_me:$LINENO: result: $ac_cv_build" >&5
     1687echo "${ECHO_T}$ac_cv_build" >&6
     1688build=$ac_cv_build
     1689build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
     1690build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
     1691build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
     1692
     1693
     1694
     1695# Check if user wants to produce debugging code
     1696
     1697echo "$as_me:$LINENO: checking whether we want to compile in debug mode" >&5
     1698echo $ECHO_N "checking whether we want to compile in debug mode... $ECHO_C" >&6
     1699
     1700# Check whether --enable-debug or --disable-debug was given.
     1701if test "${enable_debug+set}" = set; then
     1702  enableval="$enable_debug"
     1703  case "${enableval}" in
     1704   yes) coin_debug_compile=true
     1705        enable_shared=no
     1706        ;;
     1707   no)  coin_debug_compile=false
     1708        ;;
     1709   *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for --enable-debug" >&5
     1710echo "$as_me: error: bad value ${enableval} for --enable-debug" >&2;}
     1711   { (exit 1); exit 1; }; }
     1712        ;;
     1713esac
     1714else
     1715  coin_debug_compile=false
     1716fi;
     1717
     1718 # m4_ifvaln([],
     1719
     1720if test $coin_debug_compile = true; then
     1721  echo "$as_me:$LINENO: result: yes" >&5
     1722echo "${ECHO_T}yes" >&6
     1723else
     1724  echo "$as_me:$LINENO: result: no" >&5
     1725echo "${ECHO_T}no" >&6
     1726fi
     1727
     1728 # m4_ifvaln([],
     1729
     1730
     1731
     1732# Get the name of the C compiler and appropriate compiler options
     1733case $build in
     1734  *-mingw*)
     1735    if test "${LD+set}" = set; then :; else
     1736      LD=link
     1737    fi
     1738    ;;
     1739 esac
     1740 case $enable_doscompile in
     1741   msvc)
     1742     if test "x${LD+set}" = xset; then :; else
     1743       LD=link
     1744     fi
     1745     ;;
     1746 esac
     1747
     1748
     1749 # Check whether --enable-doscompile or --disable-doscompile was given.
     1750if test "${enable_doscompile+set}" = set; then
     1751  enableval="$enable_doscompile"
     1752  if test "$enable_doscompile" != no; then
     1753     case $build in
     1754       *-cygwin*) ;;
     1755       *) { { echo "$as_me:$LINENO: error: --enable-doscompile option makes sense only under Cygwin" >&5
     1756echo "$as_me: error: --enable-doscompile option makes sense only under Cygwin" >&2;}
     1757   { (exit 1); exit 1; }; } ;;
     1758     esac
     1759   fi
     1760else
     1761  enable_doscompile=no
     1762fi;
     1763 case "$enable_doscompile" in
     1764   msvc|mingw|no) ;;
     1765   yes) enable_doscompile=mingw ;;
     1766   *) { { echo "$as_me:$LINENO: error: Invalid value $enable_doscompile for --enable-doscompile.
     1767                    Try configure --help=recursive." >&5
     1768echo "$as_me: error: Invalid value $enable_doscompile for --enable-doscompile.
     1769                    Try configure --help=recursive." >&2;}
     1770   { (exit 1); exit 1; }; }
     1771      ;;
     1772  esac
     1773  if test "$enable_doscompile" != no ; then
     1774    { echo "$as_me:$LINENO: DOS compile style is: $enable_doscompile" >&5
     1775echo "$as_me: DOS compile style is: $enable_doscompile" >&6;}
     1776  fi
     1777
     1778
     1779
     1780
     1781ac_ext=c
     1782ac_cpp='$CPP $CPPFLAGS'
     1783ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     1784ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     1785ac_compiler_gnu=$ac_cv_c_compiler_gnu
     1786
     1787
     1788# For consistency, we set the C compiler to the same value of the C++
     1789# compiler, if the C++ is set, but the C compiler isn't (only for CXX=cl)
     1790if test x"$CXX" != x; then
     1791  case "$CXX" in
     1792    cl* | */cl* | CL* | */CL*)
     1793      if test x"$CC" = x; then
     1794        CC="$CXX"
     1795        { echo "$as_me:$LINENO: WARNING: C++ compiler name provided as $CXX, but CC is unset. Setting CC to $CXX" >&5
     1796echo "$as_me: WARNING: C++ compiler name provided as $CXX, but CC is unset. Setting CC to $CXX" >&2;}
     1797      fi
     1798      ;;
     1799  esac
     1800fi
     1801
     1802
     1803
     1804
     1805
     1806
     1807coin_has_cc=yes
     1808
     1809save_cflags="$CFLAGS"
     1810# For sparc-sun-solaris, promote Studio/Workshop compiler to front of list.
     1811# ToDo: If Studio/Workshop cc is not present, we may find /usr/ucb/cc, which
     1812# is likely to be a non-functional shell. But many installations will have
     1813# both cc and gcc, so promoting gcc isn't good either. How to test reliably?
     1814case $build in
     1815  *-cygwin* | *-mingw*)
     1816             if test "$enable_doscompile" = msvc ; then
     1817               comps="cl"
     1818             else
     1819               comps="gcc cl"
     1820             fi ;;
     1821  sparc-sun-solaris*)
     1822             comps="cc xlc gcc pgcc icc" ;;
     1823  *-linux-*) comps="xlc gcc cc pgcc icc" ;;
     1824  *)         comps="xlc_r xlc cc gcc pgcc icc" ;;
     1825esac
     1826
     1827# We delete the cached value, since the test might not have been
     1828# performed with our choice of compilers earlier
     1829$as_unset ac_cv_prog_CC || test "${ac_cv_prog_CC+set}" != set || { ac_cv_prog_CC=; export ac_cv_prog_CC; }
     1830# AC_MSG_NOTICE([C compiler candidates: $comps])
     1831ac_ext=c
     1832ac_cpp='$CPP $CPPFLAGS'
     1833ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     1834ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     1835ac_compiler_gnu=$ac_cv_c_compiler_gnu
     1836if test -n "$ac_tool_prefix"; then
     1837  for ac_prog in $comps
     1838  do
     1839    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     1840set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     1841echo "$as_me:$LINENO: checking for $ac_word" >&5
     1842echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     1843if test "${ac_cv_prog_CC+set}" = set; then
     1844  echo $ECHO_N "(cached) $ECHO_C" >&6
     1845else
     1846  if test -n "$CC"; then
     1847  ac_cv_prog_CC="$CC" # Let the user override the test.
     1848else
     1849as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     1850for as_dir in $PATH
     1851do
     1852  IFS=$as_save_IFS
     1853  test -z "$as_dir" && as_dir=.
     1854  for ac_exec_ext in '' $ac_executable_extensions; do
     1855  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     1856    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
     1857    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     1858    break 2
     1859  fi
     1860done
     1861done
     1862
     1863fi
     1864fi
     1865CC=$ac_cv_prog_CC
     1866if test -n "$CC"; then
     1867  echo "$as_me:$LINENO: result: $CC" >&5
     1868echo "${ECHO_T}$CC" >&6
     1869else
     1870  echo "$as_me:$LINENO: result: no" >&5
     1871echo "${ECHO_T}no" >&6
     1872fi
     1873
     1874    test -n "$CC" && break
     1875  done
     1876fi
     1877if test -z "$CC"; then
     1878  ac_ct_CC=$CC
     1879  for ac_prog in $comps
     1880do
     1881  # Extract the first word of "$ac_prog", so it can be a program name with args.
     1882set dummy $ac_prog; ac_word=$2
     1883echo "$as_me:$LINENO: checking for $ac_word" >&5
     1884echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     1885if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
     1886  echo $ECHO_N "(cached) $ECHO_C" >&6
     1887else
     1888  if test -n "$ac_ct_CC"; then
     1889  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
     1890else
     1891as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     1892for as_dir in $PATH
     1893do
     1894  IFS=$as_save_IFS
     1895  test -z "$as_dir" && as_dir=.
     1896  for ac_exec_ext in '' $ac_executable_extensions; do
     1897  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     1898    ac_cv_prog_ac_ct_CC="$ac_prog"
     1899    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     1900    break 2
     1901  fi
     1902done
     1903done
     1904
     1905fi
     1906fi
     1907ac_ct_CC=$ac_cv_prog_ac_ct_CC
     1908if test -n "$ac_ct_CC"; then
     1909  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
     1910echo "${ECHO_T}$ac_ct_CC" >&6
     1911else
     1912  echo "$as_me:$LINENO: result: no" >&5
     1913echo "${ECHO_T}no" >&6
     1914fi
     1915
     1916  test -n "$ac_ct_CC" && break
     1917done
     1918
     1919  CC=$ac_ct_CC
     1920fi
     1921
     1922
     1923test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
     1924See \`config.log' for more details." >&5
     1925echo "$as_me: error: no acceptable C compiler found in \$PATH
     1926See \`config.log' for more details." >&2;}
     1927   { (exit 1); exit 1; }; }
     1928
     1929# Provide some information about the compiler.
     1930echo "$as_me:$LINENO:" \
     1931     "checking for C compiler version" >&5
     1932ac_compiler=`set X $ac_compile; echo $2`
     1933{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
     1934  (eval $ac_compiler --version </dev/null >&5) 2>&5
     1935  ac_status=$?
     1936  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     1937  (exit $ac_status); }
     1938{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
     1939  (eval $ac_compiler -v </dev/null >&5) 2>&5
     1940  ac_status=$?
     1941  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     1942  (exit $ac_status); }
     1943{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
     1944  (eval $ac_compiler -V </dev/null >&5) 2>&5
     1945  ac_status=$?
     1946  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     1947  (exit $ac_status); }
     1948
     1949cat >conftest.$ac_ext <<_ACEOF
     1950/* confdefs.h.  */
     1951_ACEOF
     1952cat confdefs.h >>conftest.$ac_ext
     1953cat >>conftest.$ac_ext <<_ACEOF
     1954/* end confdefs.h.  */
     1955
     1956int
     1957main ()
     1958{
     1959
     1960  ;
     1961  return 0;
     1962}
     1963_ACEOF
     1964ac_clean_files_save=$ac_clean_files
     1965ac_clean_files="$ac_clean_files a.out a.exe b.out"
     1966# Try to create an executable without -o first, disregard a.out.
     1967# It will help us diagnose broken compilers, and finding out an intuition
     1968# of exeext.
     1969echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
     1970echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
     1971ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
     1972if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
     1973  (eval $ac_link_default) 2>&5
     1974  ac_status=$?
     1975  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     1976  (exit $ac_status); }; then
     1977  # Find the output, starting from the most likely.  This scheme is
     1978# not robust to junk in `.', hence go to wildcards (a.*) only as a last
     1979# resort.
     1980
     1981# Be careful to initialize this variable, since it used to be cached.
     1982# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
     1983ac_cv_exeext=
     1984# b.out is created by i960 compilers.
     1985for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
     1986do
     1987  test -f "$ac_file" || continue
     1988  case $ac_file in
     1989    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
     1990        ;;
     1991    conftest.$ac_ext )
     1992        # This is the source file.
     1993        ;;
     1994    [ab].out )
     1995        # We found the default executable, but exeext='' is most
     1996        # certainly right.
     1997        break;;
     1998    *.* )
     1999        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
     2000        # FIXME: I believe we export ac_cv_exeext for Libtool,
     2001        # but it would be cool to find out if it's true.  Does anybody
     2002        # maintain Libtool? --akim.
     2003        export ac_cv_exeext
     2004        break;;
     2005    * )
     2006        break;;
     2007  esac
     2008done
     2009else
     2010  echo "$as_me: failed program was:" >&5
     2011sed 's/^/| /' conftest.$ac_ext >&5
     2012
     2013{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
     2014See \`config.log' for more details." >&5
     2015echo "$as_me: error: C compiler cannot create executables
     2016See \`config.log' for more details." >&2;}
     2017   { (exit 77); exit 77; }; }
     2018fi
     2019
     2020ac_exeext=$ac_cv_exeext
     2021echo "$as_me:$LINENO: result: $ac_file" >&5
     2022echo "${ECHO_T}$ac_file" >&6
     2023
     2024# Check the compiler produces executables we can run.  If not, either
     2025# the compiler is broken, or we cross compile.
     2026echo "$as_me:$LINENO: checking whether the C compiler works" >&5
     2027echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
     2028# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
     2029# If not cross compiling, check that we can run a simple program.
     2030if test "$cross_compiling" != yes; then
     2031  if { ac_try='./$ac_file'
     2032  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2033  (eval $ac_try) 2>&5
     2034  ac_status=$?
     2035  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2036  (exit $ac_status); }; }; then
     2037    cross_compiling=no
     2038  else
     2039    if test "$cross_compiling" = maybe; then
     2040        cross_compiling=yes
     2041    else
     2042        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
     2043If you meant to cross compile, use \`--host'.
     2044See \`config.log' for more details." >&5
     2045echo "$as_me: error: cannot run C compiled programs.
     2046If you meant to cross compile, use \`--host'.
     2047See \`config.log' for more details." >&2;}
     2048   { (exit 1); exit 1; }; }
     2049    fi
     2050  fi
     2051fi
     2052echo "$as_me:$LINENO: result: yes" >&5
     2053echo "${ECHO_T}yes" >&6
     2054
     2055rm -f a.out a.exe conftest$ac_cv_exeext b.out
     2056ac_clean_files=$ac_clean_files_save
     2057# Check the compiler produces executables we can run.  If not, either
     2058# the compiler is broken, or we cross compile.
     2059echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
     2060echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
     2061echo "$as_me:$LINENO: result: $cross_compiling" >&5
     2062echo "${ECHO_T}$cross_compiling" >&6
     2063
     2064echo "$as_me:$LINENO: checking for suffix of executables" >&5
     2065echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
     2066if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     2067  (eval $ac_link) 2>&5
     2068  ac_status=$?
     2069  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2070  (exit $ac_status); }; then
     2071  # If both `conftest.exe' and `conftest' are `present' (well, observable)
     2072# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
     2073# work properly (i.e., refer to `conftest.exe'), while it won't with
     2074# `rm'.
     2075for ac_file in conftest.exe conftest conftest.*; do
     2076  test -f "$ac_file" || continue
     2077  case $ac_file in
     2078    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
     2079    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
     2080          export ac_cv_exeext
     2081          break;;
     2082    * ) break;;
     2083  esac
     2084done
     2085else
     2086  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
     2087See \`config.log' for more details." >&5
     2088echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
     2089See \`config.log' for more details." >&2;}
     2090   { (exit 1); exit 1; }; }
     2091fi
     2092
     2093rm -f conftest$ac_cv_exeext
     2094echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
     2095echo "${ECHO_T}$ac_cv_exeext" >&6
     2096
     2097rm -f conftest.$ac_ext
     2098EXEEXT=$ac_cv_exeext
     2099ac_exeext=$EXEEXT
     2100echo "$as_me:$LINENO: checking for suffix of object files" >&5
     2101echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
     2102if test "${ac_cv_objext+set}" = set; then
     2103  echo $ECHO_N "(cached) $ECHO_C" >&6
     2104else
     2105  cat >conftest.$ac_ext <<_ACEOF
     2106/* confdefs.h.  */
     2107_ACEOF
     2108cat confdefs.h >>conftest.$ac_ext
     2109cat >>conftest.$ac_ext <<_ACEOF
     2110/* end confdefs.h.  */
     2111
     2112int
     2113main ()
     2114{
     2115
     2116  ;
     2117  return 0;
     2118}
     2119_ACEOF
     2120rm -f conftest.o conftest.obj
     2121if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2122  (eval $ac_compile) 2>&5
     2123  ac_status=$?
     2124  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2125  (exit $ac_status); }; then
     2126  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
     2127  case $ac_file in
     2128    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
     2129    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
     2130       break;;
     2131  esac
     2132done
     2133else
     2134  echo "$as_me: failed program was:" >&5
     2135sed 's/^/| /' conftest.$ac_ext >&5
     2136
     2137{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
     2138See \`config.log' for more details." >&5
     2139echo "$as_me: error: cannot compute suffix of object files: cannot compile
     2140See \`config.log' for more details." >&2;}
     2141   { (exit 1); exit 1; }; }
     2142fi
     2143
     2144rm -f conftest.$ac_cv_objext conftest.$ac_ext
     2145fi
     2146echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
     2147echo "${ECHO_T}$ac_cv_objext" >&6
     2148OBJEXT=$ac_cv_objext
     2149ac_objext=$OBJEXT
     2150echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
     2151echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
     2152if test "${ac_cv_c_compiler_gnu+set}" = set; then
     2153  echo $ECHO_N "(cached) $ECHO_C" >&6
     2154else
     2155  cat >conftest.$ac_ext <<_ACEOF
     2156/* confdefs.h.  */
     2157_ACEOF
     2158cat confdefs.h >>conftest.$ac_ext
     2159cat >>conftest.$ac_ext <<_ACEOF
     2160/* end confdefs.h.  */
     2161
     2162int
     2163main ()
     2164{
     2165#ifndef __GNUC__
     2166       choke me
     2167#endif
     2168
     2169  ;
     2170  return 0;
     2171}
     2172_ACEOF
     2173rm -f conftest.$ac_objext
     2174if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2175  (eval $ac_compile) 2>conftest.er1
     2176  ac_status=$?
     2177  grep -v '^ *+' conftest.er1 >conftest.err
     2178  rm -f conftest.er1
     2179  cat conftest.err >&5
     2180  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2181  (exit $ac_status); } &&
     2182         { ac_try='test -z "$ac_c_werror_flag"
     2183                         || test ! -s conftest.err'
     2184  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2185  (eval $ac_try) 2>&5
     2186  ac_status=$?
     2187  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2188  (exit $ac_status); }; } &&
     2189         { ac_try='test -s conftest.$ac_objext'
     2190  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2191  (eval $ac_try) 2>&5
     2192  ac_status=$?
     2193  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2194  (exit $ac_status); }; }; then
     2195  ac_compiler_gnu=yes
     2196else
     2197  echo "$as_me: failed program was:" >&5
     2198sed 's/^/| /' conftest.$ac_ext >&5
     2199
     2200ac_compiler_gnu=no
     2201fi
     2202rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     2203ac_cv_c_compiler_gnu=$ac_compiler_gnu
     2204
     2205fi
     2206echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
     2207echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
     2208GCC=`test $ac_compiler_gnu = yes && echo yes`
     2209ac_test_CFLAGS=${CFLAGS+set}
     2210ac_save_CFLAGS=$CFLAGS
     2211CFLAGS="-g"
     2212echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
     2213echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
     2214if test "${ac_cv_prog_cc_g+set}" = set; then
     2215  echo $ECHO_N "(cached) $ECHO_C" >&6
     2216else
     2217  cat >conftest.$ac_ext <<_ACEOF
     2218/* confdefs.h.  */
     2219_ACEOF
     2220cat confdefs.h >>conftest.$ac_ext
     2221cat >>conftest.$ac_ext <<_ACEOF
     2222/* end confdefs.h.  */
     2223
     2224int
     2225main ()
     2226{
     2227
     2228  ;
     2229  return 0;
     2230}
     2231_ACEOF
     2232rm -f conftest.$ac_objext
     2233if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2234  (eval $ac_compile) 2>conftest.er1
     2235  ac_status=$?
     2236  grep -v '^ *+' conftest.er1 >conftest.err
     2237  rm -f conftest.er1
     2238  cat conftest.err >&5
     2239  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2240  (exit $ac_status); } &&
     2241         { ac_try='test -z "$ac_c_werror_flag"
     2242                         || test ! -s conftest.err'
     2243  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2244  (eval $ac_try) 2>&5
     2245  ac_status=$?
     2246  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2247  (exit $ac_status); }; } &&
     2248         { ac_try='test -s conftest.$ac_objext'
     2249  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2250  (eval $ac_try) 2>&5
     2251  ac_status=$?
     2252  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2253  (exit $ac_status); }; }; then
     2254  ac_cv_prog_cc_g=yes
     2255else
     2256  echo "$as_me: failed program was:" >&5
     2257sed 's/^/| /' conftest.$ac_ext >&5
     2258
     2259ac_cv_prog_cc_g=no
     2260fi
     2261rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     2262fi
     2263echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
     2264echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
     2265if test "$ac_test_CFLAGS" = set; then
     2266  CFLAGS=$ac_save_CFLAGS
     2267elif test $ac_cv_prog_cc_g = yes; then
     2268  if test "$GCC" = yes; then
     2269    CFLAGS="-g -O2"
     2270  else
     2271    CFLAGS="-g"
     2272  fi
     2273else
     2274  if test "$GCC" = yes; then
     2275    CFLAGS="-O2"
     2276  else
     2277    CFLAGS=
     2278  fi
     2279fi
     2280echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
     2281echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
     2282if test "${ac_cv_prog_cc_stdc+set}" = set; then
     2283  echo $ECHO_N "(cached) $ECHO_C" >&6
     2284else
     2285  ac_cv_prog_cc_stdc=no
     2286ac_save_CC=$CC
     2287cat >conftest.$ac_ext <<_ACEOF
     2288/* confdefs.h.  */
     2289_ACEOF
     2290cat confdefs.h >>conftest.$ac_ext
     2291cat >>conftest.$ac_ext <<_ACEOF
     2292/* end confdefs.h.  */
     2293#include <stdarg.h>
     2294#include <stdio.h>
     2295#include <sys/types.h>
     2296#include <sys/stat.h>
     2297/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
     2298struct buf { int x; };
     2299FILE * (*rcsopen) (struct buf *, struct stat *, int);
     2300static char *e (p, i)
     2301     char **p;
     2302     int i;
     2303{
     2304  return p[i];
     2305}
     2306static char *f (char * (*g) (char **, int), char **p, ...)
     2307{
     2308  char *s;
     2309  va_list v;
     2310  va_start (v,p);
     2311  s = g (p, va_arg (v,int));
     2312  va_end (v);
     2313  return s;
     2314}
     2315
     2316/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
     2317   function prototypes and stuff, but not '\xHH' hex character constants.
     2318   These don't provoke an error unfortunately, instead are silently treated
     2319   as 'x'.  The following induces an error, until -std1 is added to get
     2320   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
     2321   array size at least.  It's necessary to write '\x00'==0 to get something
     2322   that's true only with -std1.  */
     2323int osf4_cc_array ['\x00' == 0 ? 1 : -1];
     2324
     2325int test (int i, double x);
     2326struct s1 {int (*f) (int a);};
     2327struct s2 {int (*f) (double a);};
     2328int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
     2329int argc;
     2330char **argv;
     2331int
     2332main ()
     2333{
     2334return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
     2335  ;
     2336  return 0;
     2337}
     2338_ACEOF
     2339# Don't try gcc -ansi; that turns off useful extensions and
     2340# breaks some systems' header files.
     2341# AIX                   -qlanglvl=ansi
     2342# Ultrix and OSF/1      -std1
     2343# HP-UX 10.20 and later -Ae
     2344# HP-UX older versions  -Aa -D_HPUX_SOURCE
     2345# SVR4                  -Xc -D__EXTENSIONS__
     2346for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
     2347do
     2348  CC="$ac_save_CC $ac_arg"
     2349  rm -f conftest.$ac_objext
     2350if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2351  (eval $ac_compile) 2>conftest.er1
     2352  ac_status=$?
     2353  grep -v '^ *+' conftest.er1 >conftest.err
     2354  rm -f conftest.er1
     2355  cat conftest.err >&5
     2356  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2357  (exit $ac_status); } &&
     2358         { ac_try='test -z "$ac_c_werror_flag"
     2359                         || test ! -s conftest.err'
     2360  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2361  (eval $ac_try) 2>&5
     2362  ac_status=$?
     2363  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2364  (exit $ac_status); }; } &&
     2365         { ac_try='test -s conftest.$ac_objext'
     2366  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2367  (eval $ac_try) 2>&5
     2368  ac_status=$?
     2369  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2370  (exit $ac_status); }; }; then
     2371  ac_cv_prog_cc_stdc=$ac_arg
     2372break
     2373else
     2374  echo "$as_me: failed program was:" >&5
     2375sed 's/^/| /' conftest.$ac_ext >&5
     2376
     2377fi
     2378rm -f conftest.err conftest.$ac_objext
     2379done
     2380rm -f conftest.$ac_ext conftest.$ac_objext
     2381CC=$ac_save_CC
     2382
     2383fi
     2384
     2385case "x$ac_cv_prog_cc_stdc" in
     2386  x|xno)
     2387    echo "$as_me:$LINENO: result: none needed" >&5
     2388echo "${ECHO_T}none needed" >&6 ;;
     2389  *)
     2390    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
     2391echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
     2392    CC="$CC $ac_cv_prog_cc_stdc" ;;
     2393esac
     2394
     2395# Some people use a C++ compiler to compile C.  Since we use `exit',
     2396# in C++ we need to declare it.  In case someone uses the same compiler
     2397# for both compiling C and C++ we need to have the C++ compiler decide
     2398# the declaration of exit, since it's the most demanding environment.
     2399cat >conftest.$ac_ext <<_ACEOF
     2400#ifndef __cplusplus
     2401  choke me
     2402#endif
     2403_ACEOF
     2404rm -f conftest.$ac_objext
     2405if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2406  (eval $ac_compile) 2>conftest.er1
     2407  ac_status=$?
     2408  grep -v '^ *+' conftest.er1 >conftest.err
     2409  rm -f conftest.er1
     2410  cat conftest.err >&5
     2411  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2412  (exit $ac_status); } &&
     2413         { ac_try='test -z "$ac_c_werror_flag"
     2414                         || test ! -s conftest.err'
     2415  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2416  (eval $ac_try) 2>&5
     2417  ac_status=$?
     2418  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2419  (exit $ac_status); }; } &&
     2420         { ac_try='test -s conftest.$ac_objext'
     2421  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2422  (eval $ac_try) 2>&5
     2423  ac_status=$?
     2424  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2425  (exit $ac_status); }; }; then
     2426  for ac_declaration in \
     2427   '' \
     2428   'extern "C" void std::exit (int) throw (); using std::exit;' \
     2429   'extern "C" void std::exit (int); using std::exit;' \
     2430   'extern "C" void exit (int) throw ();' \
     2431   'extern "C" void exit (int);' \
     2432   'void exit (int);'
     2433do
     2434  cat >conftest.$ac_ext <<_ACEOF
     2435/* confdefs.h.  */
     2436_ACEOF
     2437cat confdefs.h >>conftest.$ac_ext
     2438cat >>conftest.$ac_ext <<_ACEOF
     2439/* end confdefs.h.  */
     2440$ac_declaration
     2441#include <stdlib.h>
     2442int
     2443main ()
     2444{
     2445exit (42);
     2446  ;
     2447  return 0;
     2448}
     2449_ACEOF
     2450rm -f conftest.$ac_objext
     2451if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2452  (eval $ac_compile) 2>conftest.er1
     2453  ac_status=$?
     2454  grep -v '^ *+' conftest.er1 >conftest.err
     2455  rm -f conftest.er1
     2456  cat conftest.err >&5
     2457  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2458  (exit $ac_status); } &&
     2459         { ac_try='test -z "$ac_c_werror_flag"
     2460                         || test ! -s conftest.err'
     2461  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2462  (eval $ac_try) 2>&5
     2463  ac_status=$?
     2464  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2465  (exit $ac_status); }; } &&
     2466         { ac_try='test -s conftest.$ac_objext'
     2467  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2468  (eval $ac_try) 2>&5
     2469  ac_status=$?
     2470  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2471  (exit $ac_status); }; }; then
     2472  :
     2473else
     2474  echo "$as_me: failed program was:" >&5
     2475sed 's/^/| /' conftest.$ac_ext >&5
     2476
     2477continue
     2478fi
     2479rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     2480  cat >conftest.$ac_ext <<_ACEOF
     2481/* confdefs.h.  */
     2482_ACEOF
     2483cat confdefs.h >>conftest.$ac_ext
     2484cat >>conftest.$ac_ext <<_ACEOF
     2485/* end confdefs.h.  */
     2486$ac_declaration
     2487int
     2488main ()
     2489{
     2490exit (42);
     2491  ;
     2492  return 0;
     2493}
     2494_ACEOF
     2495rm -f conftest.$ac_objext
     2496if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     2497  (eval $ac_compile) 2>conftest.er1
     2498  ac_status=$?
     2499  grep -v '^ *+' conftest.er1 >conftest.err
     2500  rm -f conftest.er1
     2501  cat conftest.err >&5
     2502  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2503  (exit $ac_status); } &&
     2504         { ac_try='test -z "$ac_c_werror_flag"
     2505                         || test ! -s conftest.err'
     2506  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2507  (eval $ac_try) 2>&5
     2508  ac_status=$?
     2509  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2510  (exit $ac_status); }; } &&
     2511         { ac_try='test -s conftest.$ac_objext'
     2512  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2513  (eval $ac_try) 2>&5
     2514  ac_status=$?
     2515  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2516  (exit $ac_status); }; }; then
     2517  break
     2518else
     2519  echo "$as_me: failed program was:" >&5
     2520sed 's/^/| /' conftest.$ac_ext >&5
     2521
     2522fi
     2523rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     2524done
     2525rm -f conftest*
     2526if test -n "$ac_declaration"; then
     2527  echo '#ifdef __cplusplus' >>confdefs.h
     2528  echo $ac_declaration      >>confdefs.h
     2529  echo '#endif'             >>confdefs.h
     2530fi
     2531
     2532else
     2533  echo "$as_me: failed program was:" >&5
     2534sed 's/^/| /' conftest.$ac_ext >&5
     2535
     2536fi
     2537rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     2538ac_ext=c
     2539ac_cpp='$CPP $CPPFLAGS'
     2540ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     2541ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     2542ac_compiler_gnu=$ac_cv_c_compiler_gnu
     2543
     2544if test -z "$CC" ; then
     2545  { { echo "$as_me:$LINENO: error: Failed to find a C compiler!" >&5
     2546echo "$as_me: error: Failed to find a C compiler!" >&2;}
     2547   { (exit 1); exit 1; }; }
     2548fi
     2549# Autoconf incorrectly concludes that cl recognises -g. It doesn't.
     2550case "$CC" in
     2551  cl* | */cl* | CL* | */CL* )
     2552    if test "$ac_cv_prog_cc_g" = yes ; then
     2553      ac_cv_prog_cc_g=no
     2554      { echo "$as_me:$LINENO: Overruling autoconf; cl does not recognise -g." >&5
     2555echo "$as_me: Overruling autoconf; cl does not recognise -g." >&6;}
     2556    fi ;;
     2557esac
     2558CFLAGS="$save_cflags"
     2559
     2560# Check if a project specific CFLAGS variable has been set
     2561if test x$COIN_PRJCT != x; then
     2562  eval coin_tmp=\${${COIN_PRJCT}_CFLAGS+set}
     2563  if test x$coin_tmp = xset; then
     2564    eval CFLAGS=\${${COIN_PRJCT}_CFLAGS}
     2565  fi
     2566fi
     2567
     2568if test x"$CFLAGS" = x; then
     2569
     2570  coin_add_cflags=
     2571  coin_opt_cflags=
     2572  coin_dbg_cflags=
     2573  coin_warn_cflags=
     2574
     2575  if test "$GCC" = "yes"; then
     2576    case "$CC" in
     2577      icc* | */icc*)
     2578        ;;
     2579      *)
     2580        coin_opt_cflags="-O3 -fomit-frame-pointer"
     2581        coin_add_cflags="-pipe"
     2582        coin_dbg_cflags="-g"
     2583        coin_warn_cflags="-pedantic-errors -Wimplicit -Wparentheses -Wsequence-point -Wreturn-type -Wcast-qual -Wall"
     2584        case $enable_doscompile in
     2585          mingw)
     2586            CFLAGS="-mno-cygwin"
     2587            cat >conftest.$ac_ext <<_ACEOF
     2588/* confdefs.h.  */
     2589_ACEOF
     2590cat confdefs.h >>conftest.$ac_ext
     2591cat >>conftest.$ac_ext <<_ACEOF
     2592/* end confdefs.h.  */
     2593
     2594int
     2595main ()
     2596{
     2597int i=0; i++;
     2598  ;
     2599  return 0;
     2600}
     2601_ACEOF
     2602rm -f conftest.$ac_objext conftest$ac_exeext
     2603if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     2604  (eval $ac_link) 2>conftest.er1
     2605  ac_status=$?
     2606  grep -v '^ *+' conftest.er1 >conftest.err
     2607  rm -f conftest.er1
     2608  cat conftest.err >&5
     2609  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2610  (exit $ac_status); } &&
     2611         { ac_try='test -z "$ac_c_werror_flag"
     2612                         || test ! -s conftest.err'
     2613  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2614  (eval $ac_try) 2>&5
     2615  ac_status=$?
     2616  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2617  (exit $ac_status); }; } &&
     2618         { ac_try='test -s conftest$ac_exeext'
     2619  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2620  (eval $ac_try) 2>&5
     2621  ac_status=$?
     2622  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2623  (exit $ac_status); }; }; then
     2624  coin_add_cflags="-mno-cygwin $coin_add_cflags"
     2625else
     2626  echo "$as_me: failed program was:" >&5
     2627sed 's/^/| /' conftest.$ac_ext >&5
     2628
     2629fi
     2630rm -f conftest.err conftest.$ac_objext \
     2631      conftest$ac_exeext conftest.$ac_ext
     2632            CFLAGS=
     2633          ;;
     2634        esac
     2635    esac
     2636  fi
     2637  if test -z "$coin_opt_cflags"; then
     2638    case $build in
     2639      *-cygwin* | *-mingw*)
     2640        case "$CC" in
     2641          cl* | */cl* | CL* | */CL*)
     2642            coin_opt_cflags='-MT -O2'
     2643            coin_add_cflags='-nologo -wd4996'
     2644            coin_dbg_cflags='-MTd'
     2645            ;;
     2646        esac
     2647        ;;
     2648      *-linux-*)
     2649        case "$CC" in
     2650          icc* | */icc*)
     2651            coin_opt_cflags="-O3 -ip"
     2652            coin_add_cflags=""
     2653            coin_dbg_cflags="-g"
     2654            # Check if -i_dynamic is necessary (for new glibc library)
     2655            CFLAGS=
     2656            cat >conftest.$ac_ext <<_ACEOF
     2657/* confdefs.h.  */
     2658_ACEOF
     2659cat confdefs.h >>conftest.$ac_ext
     2660cat >>conftest.$ac_ext <<_ACEOF
     2661/* end confdefs.h.  */
     2662
     2663int
     2664main ()
     2665{
     2666int i=0; i++;
     2667  ;
     2668  return 0;
     2669}
     2670_ACEOF
     2671rm -f conftest.$ac_objext conftest$ac_exeext
     2672if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     2673  (eval $ac_link) 2>conftest.er1
     2674  ac_status=$?
     2675  grep -v '^ *+' conftest.er1 >conftest.err
     2676  rm -f conftest.er1
     2677  cat conftest.err >&5
     2678  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2679  (exit $ac_status); } &&
     2680         { ac_try='test -z "$ac_c_werror_flag"
     2681                         || test ! -s conftest.err'
     2682  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2683  (eval $ac_try) 2>&5
     2684  ac_status=$?
     2685  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2686  (exit $ac_status); }; } &&
     2687         { ac_try='test -s conftest$ac_exeext'
     2688  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2689  (eval $ac_try) 2>&5
     2690  ac_status=$?
     2691  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2692  (exit $ac_status); }; }; then
     2693  :
     2694else
     2695  echo "$as_me: failed program was:" >&5
     2696sed 's/^/| /' conftest.$ac_ext >&5
     2697
     2698coin_add_cflags="-i_dynamic $coin_add_cflags"
     2699fi
     2700rm -f conftest.err conftest.$ac_objext \
     2701      conftest$ac_exeext conftest.$ac_ext
     2702            ;;
     2703          pgcc* | */pgcc*)
     2704            coin_opt_cflags="-fast"
     2705            coin_add_cflags="-Kieee -pc 64"
     2706            coin_dbg_cflags="-g"
     2707            ;;
     2708        esac
     2709        ;;
     2710      *-ibm-*)
     2711        case "$CC" in
     2712          xlc* | */xlc* | mpxlc* | */mpxlc*)
     2713            coin_opt_cflags="-O3 -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
     2714            coin_add_cflags="-bmaxdata:0x80000000"
     2715            coin_dbg_cflags="-g"
     2716          ;;
     2717        esac
     2718        ;;
     2719      *-hp-*)
     2720        coin_opt_cflags="-O"
     2721        coin_add_cflags="-Ae"
     2722        coin_dbg_cflags="-g"
     2723        ;;
     2724      *-sun-*)
     2725        coin_opt_cflags="-xO4"
     2726        coin_dbg_cflags="-g"
     2727        ;;
     2728      *-sgi-*)
     2729        coin_opt_cflags="-O -OPT:Olimit=0"
     2730        coin_dbg_cflags="-g"
     2731        ;;
     2732    esac
     2733  fi
     2734
     2735  if test "$ac_cv_prog_cc_g" = yes && test -z "$coin_dbg_cflags" ; then
     2736    coin_dbg_cflags="-g"
     2737  fi
     2738
     2739  if test -z "$coin_opt_cflags"; then
     2740    # Try if -O option works if nothing else is set
     2741    CFLAGS="-O"
     2742    cat >conftest.$ac_ext <<_ACEOF
     2743/* confdefs.h.  */
     2744_ACEOF
     2745cat confdefs.h >>conftest.$ac_ext
     2746cat >>conftest.$ac_ext <<_ACEOF
     2747/* end confdefs.h.  */
     2748
     2749int
     2750main ()
     2751{
     2752int i=0; i++;
     2753  ;
     2754  return 0;
     2755}
     2756_ACEOF
     2757rm -f conftest.$ac_objext conftest$ac_exeext
     2758if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     2759  (eval $ac_link) 2>conftest.er1
     2760  ac_status=$?
     2761  grep -v '^ *+' conftest.er1 >conftest.err
     2762  rm -f conftest.er1
     2763  cat conftest.err >&5
     2764  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2765  (exit $ac_status); } &&
     2766         { ac_try='test -z "$ac_c_werror_flag"
     2767                         || test ! -s conftest.err'
     2768  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2769  (eval $ac_try) 2>&5
     2770  ac_status=$?
     2771  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2772  (exit $ac_status); }; } &&
     2773         { ac_try='test -s conftest$ac_exeext'
     2774  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2775  (eval $ac_try) 2>&5
     2776  ac_status=$?
     2777  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2778  (exit $ac_status); }; }; then
     2779  coin_opt_cflags="-O"
     2780else
     2781  echo "$as_me: failed program was:" >&5
     2782sed 's/^/| /' conftest.$ac_ext >&5
     2783
     2784fi
     2785rm -f conftest.err conftest.$ac_objext \
     2786      conftest$ac_exeext conftest.$ac_ext
     2787  fi
     2788
     2789  # if PM doesn't want the warning messages, take them out
     2790  if test x"$coin_skip_warn_cflags" = xyes; then
     2791    coin_warn_cflags=
     2792  fi
     2793
     2794  if test x${DBG_CFLAGS+set} != xset; then
     2795    DBG_CFLAGS="$coin_dbg_cflags $coin_add_cflags $coin_warn_cflags"
     2796  fi
     2797  if test x${OPT_CFLAGS+set} != xset; then
     2798    OPT_CFLAGS="$coin_opt_cflags $coin_add_cflags -DNDEBUG $coin_warn_cflags"
     2799  fi
     2800
     2801  DBG_CFLAGS="$DBG_CFLAGS $ADD_CFLAGS $CDEFS"
     2802  OPT_CFLAGS="$OPT_CFLAGS $ADD_CFLAGS $CDEFS"
     2803
     2804  if test "$coin_debug_compile" = "true"; then
     2805    CFLAGS="$DBG_CFLAGS"
     2806  else
     2807    CFLAGS="$OPT_CFLAGS"
     2808  fi
     2809else
     2810  CFLAGS="$CFLAGS $ADD_CFLAGS $CDEFS"
     2811  if test x${DBG_CFLAGS+set} != xset; then
     2812    DBG_CFLAGS="$CFLAGS"
     2813  fi
     2814  if test x${OPT_CFLAGS+set} != xset; then
     2815    OPT_CFLAGS="$CFLAGS"
     2816  fi
     2817fi
     2818
     2819# If CFLAGS contains -mno-cygwin, CPPFLAGS must also have it.
     2820
     2821case "$CFLAGS" in
     2822  *-mno-cygwin*)
     2823    if test x${CPPFLAGS+set} != xset ; then
     2824      CPPFLAGS="-mno-cygwin"
     2825    else
     2826      case "$CPPFLAGS" in
     2827        *-mno-cygwin*)
     2828          ;;
     2829        *)
     2830          CPPFLAGS="$CPPFLAGS -mno-cygwin"
     2831          ;;
     2832      esac
     2833    fi ;;
     2834esac
     2835
     2836# Try if CFLAGS works
     2837save_CFLAGS="$CFLAGS"
     2838cat >conftest.$ac_ext <<_ACEOF
     2839/* confdefs.h.  */
     2840_ACEOF
     2841cat confdefs.h >>conftest.$ac_ext
     2842cat >>conftest.$ac_ext <<_ACEOF
     2843/* end confdefs.h.  */
     2844
     2845int
     2846main ()
     2847{
     2848int i=0; i++;
     2849  ;
     2850  return 0;
     2851}
     2852_ACEOF
     2853rm -f conftest.$ac_objext conftest$ac_exeext
     2854if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     2855  (eval $ac_link) 2>conftest.er1
     2856  ac_status=$?
     2857  grep -v '^ *+' conftest.er1 >conftest.err
     2858  rm -f conftest.er1
     2859  cat conftest.err >&5
     2860  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2861  (exit $ac_status); } &&
     2862         { ac_try='test -z "$ac_c_werror_flag"
     2863                         || test ! -s conftest.err'
     2864  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2865  (eval $ac_try) 2>&5
     2866  ac_status=$?
     2867  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2868  (exit $ac_status); }; } &&
     2869         { ac_try='test -s conftest$ac_exeext'
     2870  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2871  (eval $ac_try) 2>&5
     2872  ac_status=$?
     2873  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2874  (exit $ac_status); }; }; then
     2875  :
     2876else
     2877  echo "$as_me: failed program was:" >&5
     2878sed 's/^/| /' conftest.$ac_ext >&5
     2879
     2880CFLAGS=
     2881fi
     2882rm -f conftest.err conftest.$ac_objext \
     2883      conftest$ac_exeext conftest.$ac_ext
     2884if test -z "$CFLAGS"; then
     2885  { echo "$as_me:$LINENO: WARNING: The value CFLAGS=\"$save_CFLAGS\" do not work.  I will now just try '-O', but you might want to set CFLAGS manually." >&5
     2886echo "$as_me: WARNING: The value CFLAGS=\"$save_CFLAGS\" do not work.  I will now just try '-O', but you might want to set CFLAGS manually." >&2;}
     2887  CFLAGS='-O'
     2888  cat >conftest.$ac_ext <<_ACEOF
     2889/* confdefs.h.  */
     2890_ACEOF
     2891cat confdefs.h >>conftest.$ac_ext
     2892cat >>conftest.$ac_ext <<_ACEOF
     2893/* end confdefs.h.  */
     2894
     2895int
     2896main ()
     2897{
     2898int i=0; i++;
     2899  ;
     2900  return 0;
     2901}
     2902_ACEOF
     2903rm -f conftest.$ac_objext conftest$ac_exeext
     2904if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     2905  (eval $ac_link) 2>conftest.er1
     2906  ac_status=$?
     2907  grep -v '^ *+' conftest.er1 >conftest.err
     2908  rm -f conftest.er1
     2909  cat conftest.err >&5
     2910  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2911  (exit $ac_status); } &&
     2912         { ac_try='test -z "$ac_c_werror_flag"
     2913                         || test ! -s conftest.err'
     2914  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2915  (eval $ac_try) 2>&5
     2916  ac_status=$?
     2917  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2918  (exit $ac_status); }; } &&
     2919         { ac_try='test -s conftest$ac_exeext'
     2920  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     2921  (eval $ac_try) 2>&5
     2922  ac_status=$?
     2923  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     2924  (exit $ac_status); }; }; then
     2925  :
     2926else
     2927  echo "$as_me: failed program was:" >&5
     2928sed 's/^/| /' conftest.$ac_ext >&5
     2929
     2930CFLAGS=
     2931fi
     2932rm -f conftest.err conftest.$ac_objext \
     2933      conftest$ac_exeext conftest.$ac_ext
     2934  if test -z "$CFLAGS"; then
     2935    { echo "$as_me:$LINENO: WARNING: This value for CFLAGS does not work.  I will continue with empty CFLAGS, but you might want to set CFLAGS manually." >&5
     2936echo "$as_me: WARNING: This value for CFLAGS does not work.  I will continue with empty CFLAGS, but you might want to set CFLAGS manually." >&2;}
     2937  fi
     2938fi
     2939
     2940{ echo "$as_me:$LINENO: C compiler options are: $CFLAGS" >&5
     2941echo "$as_me: C compiler options are: $CFLAGS" >&6;}
     2942
     2943
     2944if test x"$MPICC" = x; then :; else
     2945  { echo "$as_me:$LINENO: Will use MPI C compiler $MPICC" >&5
     2946echo "$as_me: Will use MPI C compiler $MPICC" >&6;}
     2947  CC="$MPICC"
     2948fi
     2949
     2950# Correct ADDLIBS initialization if we are using the MS compiler
     2951case "$CC" in
     2952  cl* | */cl* | CL* | */CL*)
     2953    ADDLIBS=
     2954    case $build in
     2955  *-mingw*)
     2956    if test "${LD+set}" = set; then :; else
     2957      LD=link
     2958    fi
     2959    ;;
     2960 esac
     2961 case $enable_doscompile in
     2962   msvc)
     2963     if test "x${LD+set}" = xset; then :; else
     2964       LD=link
     2965     fi
     2966     ;;
     2967 esac
     2968
     2969    ;;
     2970esac
     2971
     2972ac_ext=c
     2973ac_cpp='$CPP $CPPFLAGS'
     2974ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     2975ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     2976ac_compiler_gnu=$ac_cv_c_compiler_gnu
     2977
     2978
     2979
     2980# Get the name of the C++ compiler and appropriate compiler options
     2981
     2982 #Let's try if that overcomes configuration problem with VC++ 6.0
     2983
     2984ac_ext=cc
     2985ac_cpp='$CXXCPP $CPPFLAGS'
     2986ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     2987ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     2988ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     2989
     2990
     2991
     2992
     2993
     2994
     2995
     2996coin_has_cxx=yes
     2997
     2998save_cxxflags="$CXXFLAGS"
     2999# For sparc-sun-solaris, promote Studio/Workshop compiler to front of list.
     3000case $build in
     3001  *-cygwin* | *-mingw*)
     3002             if test "$enable_doscompile" = msvc ; then
     3003               comps="cl"
     3004             else
     3005               comps="g++ cl"
     3006             fi ;;
     3007  sparc-sun-solaris*)
     3008             comps="CC xlC aCC g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC" ;;
     3009  *-darwin*) comps="g++ c++ CC" ;;
     3010          *) comps="xlC aCC CC g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC" ;;
     3011esac
     3012
     3013# We delete the cached value, since the test might not have been
     3014# performed with our choice of compilers earlier
     3015$as_unset ac_cv_prog_CXX || test "${ac_cv_prog_CXX+set}" != set || { ac_cv_prog_CXX=; export ac_cv_prog_CXX; }
     3016# AC_MSG_NOTICE([C++ compiler candidates: $comps])
     3017ac_ext=cc
     3018ac_cpp='$CXXCPP $CPPFLAGS'
     3019ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     3020ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     3021ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     3022if test -n "$ac_tool_prefix"; then
     3023  for ac_prog in $CCC $comps
     3024  do
     3025    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     3026set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     3027echo "$as_me:$LINENO: checking for $ac_word" >&5
     3028echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     3029if test "${ac_cv_prog_CXX+set}" = set; then
     3030  echo $ECHO_N "(cached) $ECHO_C" >&6
     3031else
     3032  if test -n "$CXX"; then
     3033  ac_cv_prog_CXX="$CXX" # Let the user override the test.
     3034else
     3035as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3036for as_dir in $PATH
     3037do
     3038  IFS=$as_save_IFS
     3039  test -z "$as_dir" && as_dir=.
     3040  for ac_exec_ext in '' $ac_executable_extensions; do
     3041  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3042    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
     3043    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     3044    break 2
     3045  fi
     3046done
     3047done
     3048
     3049fi
     3050fi
     3051CXX=$ac_cv_prog_CXX
     3052if test -n "$CXX"; then
     3053  echo "$as_me:$LINENO: result: $CXX" >&5
     3054echo "${ECHO_T}$CXX" >&6
     3055else
     3056  echo "$as_me:$LINENO: result: no" >&5
     3057echo "${ECHO_T}no" >&6
     3058fi
     3059
     3060    test -n "$CXX" && break
     3061  done
     3062fi
     3063if test -z "$CXX"; then
     3064  ac_ct_CXX=$CXX
     3065  for ac_prog in $CCC $comps
     3066do
     3067  # Extract the first word of "$ac_prog", so it can be a program name with args.
     3068set dummy $ac_prog; ac_word=$2
     3069echo "$as_me:$LINENO: checking for $ac_word" >&5
     3070echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     3071if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
     3072  echo $ECHO_N "(cached) $ECHO_C" >&6
     3073else
     3074  if test -n "$ac_ct_CXX"; then
     3075  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
     3076else
     3077as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3078for as_dir in $PATH
     3079do
     3080  IFS=$as_save_IFS
     3081  test -z "$as_dir" && as_dir=.
     3082  for ac_exec_ext in '' $ac_executable_extensions; do
     3083  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3084    ac_cv_prog_ac_ct_CXX="$ac_prog"
     3085    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     3086    break 2
     3087  fi
     3088done
     3089done
     3090
     3091fi
     3092fi
     3093ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
     3094if test -n "$ac_ct_CXX"; then
     3095  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
     3096echo "${ECHO_T}$ac_ct_CXX" >&6
     3097else
     3098  echo "$as_me:$LINENO: result: no" >&5
     3099echo "${ECHO_T}no" >&6
     3100fi
     3101
     3102  test -n "$ac_ct_CXX" && break
     3103done
     3104test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
     3105
     3106  CXX=$ac_ct_CXX
     3107fi
     3108
     3109
     3110# Provide some information about the compiler.
     3111echo "$as_me:$LINENO:" \
     3112     "checking for C++ compiler version" >&5
     3113ac_compiler=`set X $ac_compile; echo $2`
     3114{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
     3115  (eval $ac_compiler --version </dev/null >&5) 2>&5
     3116  ac_status=$?
     3117  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3118  (exit $ac_status); }
     3119{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
     3120  (eval $ac_compiler -v </dev/null >&5) 2>&5
     3121  ac_status=$?
     3122  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3123  (exit $ac_status); }
     3124{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
     3125  (eval $ac_compiler -V </dev/null >&5) 2>&5
     3126  ac_status=$?
     3127  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3128  (exit $ac_status); }
     3129
     3130echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
     3131echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
     3132if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
     3133  echo $ECHO_N "(cached) $ECHO_C" >&6
     3134else
     3135  cat >conftest.$ac_ext <<_ACEOF
     3136/* confdefs.h.  */
     3137_ACEOF
     3138cat confdefs.h >>conftest.$ac_ext
     3139cat >>conftest.$ac_ext <<_ACEOF
     3140/* end confdefs.h.  */
     3141
     3142int
     3143main ()
     3144{
     3145#ifndef __GNUC__
     3146       choke me
     3147#endif
     3148
     3149  ;
     3150  return 0;
     3151}
     3152_ACEOF
     3153rm -f conftest.$ac_objext
     3154if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     3155  (eval $ac_compile) 2>conftest.er1
     3156  ac_status=$?
     3157  grep -v '^ *+' conftest.er1 >conftest.err
     3158  rm -f conftest.er1
     3159  cat conftest.err >&5
     3160  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3161  (exit $ac_status); } &&
     3162         { ac_try='test -z "$ac_cxx_werror_flag"
     3163                         || test ! -s conftest.err'
     3164  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3165  (eval $ac_try) 2>&5
     3166  ac_status=$?
     3167  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3168  (exit $ac_status); }; } &&
     3169         { ac_try='test -s conftest.$ac_objext'
     3170  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3171  (eval $ac_try) 2>&5
     3172  ac_status=$?
     3173  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3174  (exit $ac_status); }; }; then
     3175  ac_compiler_gnu=yes
     3176else
     3177  echo "$as_me: failed program was:" >&5
     3178sed 's/^/| /' conftest.$ac_ext >&5
     3179
     3180ac_compiler_gnu=no
     3181fi
     3182rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     3183ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
     3184
     3185fi
     3186echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
     3187echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
     3188GXX=`test $ac_compiler_gnu = yes && echo yes`
     3189ac_test_CXXFLAGS=${CXXFLAGS+set}
     3190ac_save_CXXFLAGS=$CXXFLAGS
     3191CXXFLAGS="-g"
     3192echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
     3193echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
     3194if test "${ac_cv_prog_cxx_g+set}" = set; then
     3195  echo $ECHO_N "(cached) $ECHO_C" >&6
     3196else
     3197  cat >conftest.$ac_ext <<_ACEOF
     3198/* confdefs.h.  */
     3199_ACEOF
     3200cat confdefs.h >>conftest.$ac_ext
     3201cat >>conftest.$ac_ext <<_ACEOF
     3202/* end confdefs.h.  */
     3203
     3204int
     3205main ()
     3206{
     3207
     3208  ;
     3209  return 0;
     3210}
     3211_ACEOF
     3212rm -f conftest.$ac_objext
     3213if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     3214  (eval $ac_compile) 2>conftest.er1
     3215  ac_status=$?
     3216  grep -v '^ *+' conftest.er1 >conftest.err
     3217  rm -f conftest.er1
     3218  cat conftest.err >&5
     3219  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3220  (exit $ac_status); } &&
     3221         { ac_try='test -z "$ac_cxx_werror_flag"
     3222                         || test ! -s conftest.err'
     3223  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3224  (eval $ac_try) 2>&5
     3225  ac_status=$?
     3226  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3227  (exit $ac_status); }; } &&
     3228         { ac_try='test -s conftest.$ac_objext'
     3229  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3230  (eval $ac_try) 2>&5
     3231  ac_status=$?
     3232  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3233  (exit $ac_status); }; }; then
     3234  ac_cv_prog_cxx_g=yes
     3235else
     3236  echo "$as_me: failed program was:" >&5
     3237sed 's/^/| /' conftest.$ac_ext >&5
     3238
     3239ac_cv_prog_cxx_g=no
     3240fi
     3241rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     3242fi
     3243echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
     3244echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
     3245if test "$ac_test_CXXFLAGS" = set; then
     3246  CXXFLAGS=$ac_save_CXXFLAGS
     3247elif test $ac_cv_prog_cxx_g = yes; then
     3248  if test "$GXX" = yes; then
     3249    CXXFLAGS="-g -O2"
     3250  else
     3251    CXXFLAGS="-g"
     3252  fi
     3253else
     3254  if test "$GXX" = yes; then
     3255    CXXFLAGS="-O2"
     3256  else
     3257    CXXFLAGS=
     3258  fi
     3259fi
     3260for ac_declaration in \
     3261   '' \
     3262   'extern "C" void std::exit (int) throw (); using std::exit;' \
     3263   'extern "C" void std::exit (int); using std::exit;' \
     3264   'extern "C" void exit (int) throw ();' \
     3265   'extern "C" void exit (int);' \
     3266   'void exit (int);'
     3267do
     3268  cat >conftest.$ac_ext <<_ACEOF
     3269/* confdefs.h.  */
     3270_ACEOF
     3271cat confdefs.h >>conftest.$ac_ext
     3272cat >>conftest.$ac_ext <<_ACEOF
     3273/* end confdefs.h.  */
     3274$ac_declaration
     3275#include <stdlib.h>
     3276int
     3277main ()
     3278{
     3279exit (42);
     3280  ;
     3281  return 0;
     3282}
     3283_ACEOF
     3284rm -f conftest.$ac_objext
     3285if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     3286  (eval $ac_compile) 2>conftest.er1
     3287  ac_status=$?
     3288  grep -v '^ *+' conftest.er1 >conftest.err
     3289  rm -f conftest.er1
     3290  cat conftest.err >&5
     3291  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3292  (exit $ac_status); } &&
     3293         { ac_try='test -z "$ac_cxx_werror_flag"
     3294                         || test ! -s conftest.err'
     3295  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3296  (eval $ac_try) 2>&5
     3297  ac_status=$?
     3298  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3299  (exit $ac_status); }; } &&
     3300         { ac_try='test -s conftest.$ac_objext'
     3301  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3302  (eval $ac_try) 2>&5
     3303  ac_status=$?
     3304  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3305  (exit $ac_status); }; }; then
     3306  :
     3307else
     3308  echo "$as_me: failed program was:" >&5
     3309sed 's/^/| /' conftest.$ac_ext >&5
     3310
     3311continue
     3312fi
     3313rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     3314  cat >conftest.$ac_ext <<_ACEOF
     3315/* confdefs.h.  */
     3316_ACEOF
     3317cat confdefs.h >>conftest.$ac_ext
     3318cat >>conftest.$ac_ext <<_ACEOF
     3319/* end confdefs.h.  */
     3320$ac_declaration
     3321int
     3322main ()
     3323{
     3324exit (42);
     3325  ;
     3326  return 0;
     3327}
     3328_ACEOF
     3329rm -f conftest.$ac_objext
     3330if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     3331  (eval $ac_compile) 2>conftest.er1
     3332  ac_status=$?
     3333  grep -v '^ *+' conftest.er1 >conftest.err
     3334  rm -f conftest.er1
     3335  cat conftest.err >&5
     3336  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3337  (exit $ac_status); } &&
     3338         { ac_try='test -z "$ac_cxx_werror_flag"
     3339                         || test ! -s conftest.err'
     3340  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3341  (eval $ac_try) 2>&5
     3342  ac_status=$?
     3343  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3344  (exit $ac_status); }; } &&
     3345         { ac_try='test -s conftest.$ac_objext'
     3346  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3347  (eval $ac_try) 2>&5
     3348  ac_status=$?
     3349  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3350  (exit $ac_status); }; }; then
     3351  break
     3352else
     3353  echo "$as_me: failed program was:" >&5
     3354sed 's/^/| /' conftest.$ac_ext >&5
     3355
     3356fi
     3357rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     3358done
     3359rm -f conftest*
     3360if test -n "$ac_declaration"; then
     3361  echo '#ifdef __cplusplus' >>confdefs.h
     3362  echo $ac_declaration      >>confdefs.h
     3363  echo '#endif'             >>confdefs.h
     3364fi
     3365
     3366ac_ext=cc
     3367ac_cpp='$CXXCPP $CPPFLAGS'
     3368ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     3369ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     3370ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     3371
     3372if test -z "$CXX" ; then
     3373  { { echo "$as_me:$LINENO: error: Failed to find a C++ compiler!" >&5
     3374echo "$as_me: error: Failed to find a C++ compiler!" >&2;}
     3375   { (exit 1); exit 1; }; }
     3376fi
     3377
     3378# Autoconf incorrectly concludes that cl recognises -g. It doesn't.
     3379case "$CXX" in
     3380  cl* | */cl* | CL* | */CL* )
     3381    if test "$ac_cv_prog_cxx_g" = yes ; then
     3382      ac_cv_prog_cxx_g=no
     3383      { echo "$as_me:$LINENO: Overruling autoconf; cl does not recognise -g." >&5
     3384echo "$as_me: Overruling autoconf; cl does not recognise -g." >&6;}
     3385    fi ;;
     3386esac
     3387CXXFLAGS="$save_cxxflags"
     3388
     3389# Check if a project specific CXXFLAGS variable has been set
     3390if test x$COIN_PRJCT != x; then
     3391  eval coin_tmp=\${${COIN_PRJCT}_CXXFLAGS+set}
     3392  if test x$coin_tmp = xset; then
     3393    eval CXXFLAGS=\${${COIN_PRJCT}_CXXFLAGS}
     3394  fi
     3395fi
     3396
     3397if test x"$CXXFLAGS" = x; then
     3398
     3399# ToDo decide whether we want -DNDEBUG for optimization
     3400  coin_add_cxxflags=
     3401  coin_opt_cxxflags=
     3402  coin_dbg_cxxflags=
     3403  coin_warn_cxxflags=
     3404
     3405  if test "$GXX" = "yes"; then
     3406    case "$CXX" in
     3407      icpc* | */icpc*)
     3408        ;;
     3409      *)
     3410# ToDo decide about unroll-loops
     3411        coin_opt_cxxflags="-O3 -fomit-frame-pointer"
     3412        coin_add_cxxflags="-pipe"
     3413        coin_dbg_cxxflags="-g"
     3414        coin_warn_cxxflags="-pedantic-errors -Wimplicit -Wparentheses -Wreturn-type -Wcast-qual -Wall -Wpointer-arith -Wwrite-strings -Wconversion"
     3415        case $enable_doscompile in
     3416          mingw)
     3417            CXXFLAGS="-mno-cygwin"
     3418            cat >conftest.$ac_ext <<_ACEOF
     3419/* confdefs.h.  */
     3420_ACEOF
     3421cat confdefs.h >>conftest.$ac_ext
     3422cat >>conftest.$ac_ext <<_ACEOF
     3423/* end confdefs.h.  */
     3424
     3425int
     3426main ()
     3427{
     3428int i=0; i++;
     3429  ;
     3430  return 0;
     3431}
     3432_ACEOF
     3433rm -f conftest.$ac_objext conftest$ac_exeext
     3434if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     3435  (eval $ac_link) 2>conftest.er1
     3436  ac_status=$?
     3437  grep -v '^ *+' conftest.er1 >conftest.err
     3438  rm -f conftest.er1
     3439  cat conftest.err >&5
     3440  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3441  (exit $ac_status); } &&
     3442         { ac_try='test -z "$ac_cxx_werror_flag"
     3443                         || test ! -s conftest.err'
     3444  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3445  (eval $ac_try) 2>&5
     3446  ac_status=$?
     3447  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3448  (exit $ac_status); }; } &&
     3449         { ac_try='test -s conftest$ac_exeext'
     3450  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3451  (eval $ac_try) 2>&5
     3452  ac_status=$?
     3453  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3454  (exit $ac_status); }; }; then
     3455  coin_add_cxxflags="-mno-cygwin $coin_add_cxxflags"
     3456else
     3457  echo "$as_me: failed program was:" >&5
     3458sed 's/^/| /' conftest.$ac_ext >&5
     3459
     3460fi
     3461rm -f conftest.err conftest.$ac_objext \
     3462      conftest$ac_exeext conftest.$ac_ext
     3463            CXXFLAGS=
     3464            ;;
     3465        esac
     3466    esac
     3467  fi
     3468
     3469# Note that we do not need to cover GCC in the following tests.
     3470
     3471  if test -z "$coin_opt_cxxflags"; then
     3472    case $build in
     3473      *-cygwin* | *-mingw*)
     3474        case "$CXX" in
     3475          cl* | */cl* | CL* | */CL*)
     3476            # The MT and MTd options are mutually exclusive
     3477            coin_opt_cxxflags='-MT -O2'
     3478            coin_add_cxxflags='-nologo -EHsc -GR -wd4996'
     3479            coin_dbg_cxxflags='-MTd'
     3480            ;;
     3481        esac
     3482        ;;
     3483      *-linux-*)
     3484        case "$CXX" in
     3485          icpc* | */icpc*)
     3486            coin_opt_cxxflags="-O3 -ip"
     3487            coin_add_cxxflags=""
     3488            coin_dbg_cxxflags="-g"
     3489            # Check if -i_dynamic is necessary (for new glibc library)
     3490            CXXFLAGS=
     3491            cat >conftest.$ac_ext <<_ACEOF
     3492/* confdefs.h.  */
     3493_ACEOF
     3494cat confdefs.h >>conftest.$ac_ext
     3495cat >>conftest.$ac_ext <<_ACEOF
     3496/* end confdefs.h.  */
     3497
     3498int
     3499main ()
     3500{
     3501int i=0; i++;
     3502  ;
     3503  return 0;
     3504}
     3505_ACEOF
     3506rm -f conftest.$ac_objext conftest$ac_exeext
     3507if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     3508  (eval $ac_link) 2>conftest.er1
     3509  ac_status=$?
     3510  grep -v '^ *+' conftest.er1 >conftest.err
     3511  rm -f conftest.er1
     3512  cat conftest.err >&5
     3513  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3514  (exit $ac_status); } &&
     3515         { ac_try='test -z "$ac_cxx_werror_flag"
     3516                         || test ! -s conftest.err'
     3517  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3518  (eval $ac_try) 2>&5
     3519  ac_status=$?
     3520  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3521  (exit $ac_status); }; } &&
     3522         { ac_try='test -s conftest$ac_exeext'
     3523  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3524  (eval $ac_try) 2>&5
     3525  ac_status=$?
     3526  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3527  (exit $ac_status); }; }; then
     3528  :
     3529else
     3530  echo "$as_me: failed program was:" >&5
     3531sed 's/^/| /' conftest.$ac_ext >&5
     3532
     3533coin_add_cxxflags="-i_dynamic $coin_add_cxxflags"
     3534fi
     3535rm -f conftest.err conftest.$ac_objext \
     3536      conftest$ac_exeext conftest.$ac_ext
     3537            ;;
     3538          pgCC* | */pgCC*)
     3539            coin_opt_cxxflags="-fast"
     3540            coin_add_cxxflags="-Kieee -pc 64"
     3541            coin_dbg_cxxflags="-g"
     3542            ;;
     3543        esac
     3544        ;;
     3545      *-ibm-*)
     3546        case "$CXX" in
     3547          xlC* | */xlC* | mpxlC* | */mpxlC*)
     3548            coin_opt_cxxflags="-O3 -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
     3549            coin_add_cxxflags="-bmaxdata:0x80000000 -qrtti=dyna"
     3550            coin_dbg_cxxflags="-g"
     3551            ;;
     3552        esac
     3553        ;;
     3554      *-hp-*)
     3555        case "$CXX" in
     3556          aCC* | */aCC* )
     3557            coin_opt_cxxflags="-O"
     3558            coin_add_cxxflags="-AA"
     3559            coin_dbg_cxxflags="-g"
     3560            ;;
     3561        esac
     3562        ;;
     3563      *-sun-*)
     3564          coin_opt_cxxflags="-O4"
     3565          coin_dbg_cxxflags="-g"
     3566        ;;
     3567    esac
     3568  fi
     3569
     3570# Generic flag settings. If these don't work, add a case above.
     3571
     3572  if test "$ac_cv_prog_cxx_g" = yes && test -z "$coin_dbg_cxxflags" ; then
     3573    coin_dbg_cxxflags="-g"
     3574  fi
     3575
     3576  if test -z "$coin_opt_cxxflags"; then
     3577    # Try if -O option works if nothing else is set
     3578    CXXFLAGS=-O
     3579    cat >conftest.$ac_ext <<_ACEOF
     3580/* confdefs.h.  */
     3581_ACEOF
     3582cat confdefs.h >>conftest.$ac_ext
     3583cat >>conftest.$ac_ext <<_ACEOF
     3584/* end confdefs.h.  */
     3585
     3586int
     3587main ()
     3588{
     3589int i=0; i++;
     3590  ;
     3591  return 0;
     3592}
     3593_ACEOF
     3594rm -f conftest.$ac_objext conftest$ac_exeext
     3595if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     3596  (eval $ac_link) 2>conftest.er1
     3597  ac_status=$?
     3598  grep -v '^ *+' conftest.er1 >conftest.err
     3599  rm -f conftest.er1
     3600  cat conftest.err >&5
     3601  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3602  (exit $ac_status); } &&
     3603         { ac_try='test -z "$ac_cxx_werror_flag"
     3604                         || test ! -s conftest.err'
     3605  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3606  (eval $ac_try) 2>&5
     3607  ac_status=$?
     3608  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3609  (exit $ac_status); }; } &&
     3610         { ac_try='test -s conftest$ac_exeext'
     3611  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3612  (eval $ac_try) 2>&5
     3613  ac_status=$?
     3614  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3615  (exit $ac_status); }; }; then
     3616  coin_opt_cxxflags="-O"
     3617else
     3618  echo "$as_me: failed program was:" >&5
     3619sed 's/^/| /' conftest.$ac_ext >&5
     3620
     3621fi
     3622rm -f conftest.err conftest.$ac_objext \
     3623      conftest$ac_exeext conftest.$ac_ext
     3624  fi
     3625
     3626  # if PM doesn't want the warning messages, take them out
     3627  if test x"$coin_skip_warn_cxxflags" = xyes; then
     3628    coin_warn_cxxflags=
     3629  fi
     3630
     3631# Do final setup of flags based on values determined above.
     3632
     3633  if test x${DBG_CXXFLAGS+set} != xset; then
     3634    DBG_CXXFLAGS="$coin_dbg_cxxflags $coin_add_cxxflags $coin_warn_cxxflags"
     3635  fi
     3636  if test x${OPT_CXXFLAGS+set} != xset; then
     3637    OPT_CXXFLAGS="$coin_opt_cxxflags $coin_add_cxxflags -DNDEBUG $coin_warn_cxxflags"
     3638  fi
     3639
     3640  DBG_CXXFLAGS="$DBG_CXXFLAGS $ADD_CXXFLAGS $CXXDEFS"
     3641  OPT_CXXFLAGS="$OPT_CXXFLAGS $ADD_CXXFLAGS $CXXDEFS"
     3642
     3643  if test "$coin_debug_compile" = "true"; then
     3644    CXXFLAGS="$DBG_CXXFLAGS"
     3645  else
     3646    CXXFLAGS="$OPT_CXXFLAGS"
     3647  fi
     3648
     3649# Handle the case where CXXFLAGS was set externally.
     3650else
     3651  CXXFLAGS="$CXXFLAGS $ADD_CXXFLAGS $CXXDEFS"
     3652  if test x${DBG_CXXFLAGS+set} != xset; then
     3653    DBG_CXXFLAGS="$CXXFLAGS"
     3654  fi
     3655  if test x${OPT_CXXFLAGS+set} != xset; then
     3656    OPT_CXXFLAGS="$CXXFLAGS"
     3657  fi
     3658fi
     3659
     3660# If CXXFLAGS contains -mno-cygwin, CPPFLAGS must also have it.
     3661
     3662case "$CXXFLAGS" in
     3663  *-mno-cygwin*)
     3664    if test x${CPPFLAGS+set} != xset ; then
     3665      CPPFLAGS="-mno-cygwin"
     3666    else
     3667      case "$CPPFLAGS" in
     3668        *-mno-cygwin*)
     3669          ;;
     3670        *)
     3671          CPPFLAGS="$CPPFLAGS -mno-cygwin"
     3672          ;;
     3673      esac
     3674    fi ;;
     3675esac
     3676
     3677# Try if CXXFLAGS works
     3678save_CXXFLAGS="$CXXFLAGS"
     3679cat >conftest.$ac_ext <<_ACEOF
     3680/* confdefs.h.  */
     3681_ACEOF
     3682cat confdefs.h >>conftest.$ac_ext
     3683cat >>conftest.$ac_ext <<_ACEOF
     3684/* end confdefs.h.  */
     3685
     3686int
     3687main ()
     3688{
     3689int i=0; i++;
     3690  ;
     3691  return 0;
     3692}
     3693_ACEOF
     3694rm -f conftest.$ac_objext conftest$ac_exeext
     3695if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     3696  (eval $ac_link) 2>conftest.er1
     3697  ac_status=$?
     3698  grep -v '^ *+' conftest.er1 >conftest.err
     3699  rm -f conftest.er1
     3700  cat conftest.err >&5
     3701  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3702  (exit $ac_status); } &&
     3703         { ac_try='test -z "$ac_cxx_werror_flag"
     3704                         || test ! -s conftest.err'
     3705  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3706  (eval $ac_try) 2>&5
     3707  ac_status=$?
     3708  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3709  (exit $ac_status); }; } &&
     3710         { ac_try='test -s conftest$ac_exeext'
     3711  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3712  (eval $ac_try) 2>&5
     3713  ac_status=$?
     3714  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3715  (exit $ac_status); }; }; then
     3716  :
     3717else
     3718  echo "$as_me: failed program was:" >&5
     3719sed 's/^/| /' conftest.$ac_ext >&5
     3720
     3721CXXFLAGS=
     3722fi
     3723rm -f conftest.err conftest.$ac_objext \
     3724      conftest$ac_exeext conftest.$ac_ext
     3725if test -z "$CXXFLAGS"; then
     3726  { echo "$as_me:$LINENO: WARNING: The flags CXXFLAGS=\"$save_CXXFLAGS\" do not work.  I will now just try '-O', but you might want to set CXXFLAGS manually." >&5
     3727echo "$as_me: WARNING: The flags CXXFLAGS=\"$save_CXXFLAGS\" do not work.  I will now just try '-O', but you might want to set CXXFLAGS manually." >&2;}
     3728  CXXFLAGS='-O'
     3729  cat >conftest.$ac_ext <<_ACEOF
     3730/* confdefs.h.  */
     3731_ACEOF
     3732cat confdefs.h >>conftest.$ac_ext
     3733cat >>conftest.$ac_ext <<_ACEOF
     3734/* end confdefs.h.  */
     3735
     3736int
     3737main ()
     3738{
     3739int i=0; i++;
     3740  ;
     3741  return 0;
     3742}
     3743_ACEOF
     3744rm -f conftest.$ac_objext conftest$ac_exeext
     3745if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     3746  (eval $ac_link) 2>conftest.er1
     3747  ac_status=$?
     3748  grep -v '^ *+' conftest.er1 >conftest.err
     3749  rm -f conftest.er1
     3750  cat conftest.err >&5
     3751  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3752  (exit $ac_status); } &&
     3753         { ac_try='test -z "$ac_cxx_werror_flag"
     3754                         || test ! -s conftest.err'
     3755  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3756  (eval $ac_try) 2>&5
     3757  ac_status=$?
     3758  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3759  (exit $ac_status); }; } &&
     3760         { ac_try='test -s conftest$ac_exeext'
     3761  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     3762  (eval $ac_try) 2>&5
     3763  ac_status=$?
     3764  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3765  (exit $ac_status); }; }; then
     3766  :
     3767else
     3768  echo "$as_me: failed program was:" >&5
     3769sed 's/^/| /' conftest.$ac_ext >&5
     3770
     3771CXXFLAGS=
     3772fi
     3773rm -f conftest.err conftest.$ac_objext \
     3774      conftest$ac_exeext conftest.$ac_ext
     3775  if test -z "$CXXFLAGS"; then
     3776    { echo "$as_me:$LINENO: WARNING: This value for CXXFLAGS does not work.  I will continue with empty CXXFLAGS, but you might want to set CXXFLAGS manually." >&5
     3777echo "$as_me: WARNING: This value for CXXFLAGS does not work.  I will continue with empty CXXFLAGS, but you might want to set CXXFLAGS manually." >&2;}
     3778  fi
     3779fi
     3780
     3781{ echo "$as_me:$LINENO: C++ compiler options are: $CXXFLAGS" >&5
     3782echo "$as_me: C++ compiler options are: $CXXFLAGS" >&6;}
     3783
     3784
     3785if test x"$MPICXX" = x; then :; else
     3786  { echo "$as_me:$LINENO: Will use MPI C++ compiler $MPICXX" >&5
     3787echo "$as_me: Will use MPI C++ compiler $MPICXX" >&6;}
     3788  CXX="$MPICXX"
     3789fi
     3790
     3791case "$CXX" in
     3792  cl* | */cl* | CL* | */CL* )
     3793    case $build in
     3794  *-mingw*)
     3795    if test "${LD+set}" = set; then :; else
     3796      LD=link
     3797    fi
     3798    ;;
     3799 esac
     3800 case $enable_doscompile in
     3801   msvc)
     3802     if test "x${LD+set}" = xset; then :; else
     3803       LD=link
     3804     fi
     3805     ;;
     3806 esac
     3807
     3808    ;;
     3809esac
     3810
     3811ac_ext=c
     3812ac_cpp='$CPP $CPPFLAGS'
     3813ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     3814ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     3815ac_compiler_gnu=$ac_cv_c_compiler_gnu
     3816
     3817
     3818
     3819# Get the name of the Fortran compiler and appropriate compiler options
     3820case $build in
     3821  *-cygwin* | *-mingw*)
     3822     if test "$enable_doscompile" = msvc ; then
     3823       coin_f77_comps="ifort fl32"
     3824     else
     3825       coin_f77_comps="gfortran g77 ifort fl32"
     3826     fi ;;
     3827  sparc-sun-solaris*)
     3828     coin_f77_comps="f95 f90 f77 xlf fort77 gfortran g77 pgf90 pgf77 ifort ifc frt af77" ;;
     3829  *) coin_f77_comps="xlf fort77 gfortran f77 g77 pgf90 pgf77 ifort ifc frt af77" ;;
     3830 esac
     3831
     3832
     3833
     3834
     3835
     3836
     3837ac_ext=f
     3838ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     3839ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     3840ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     3841
     3842
     3843
     3844
     3845
     3846
     3847coin_has_f77=yes
     3848
     3849save_fflags="$FFLAGS"
     3850
     3851# We delete the cached value, since the test might not have been
     3852# performed with our choice of compilers earlier
     3853$as_unset ac_cv_prog_F77 || test "${ac_cv_prog_F77+set}" != set || { ac_cv_prog_F77=; export ac_cv_prog_F77; }
     3854
     3855# This is a real belt-and-suspenders approach. AC_COIN_FIND_F77 will use
     3856# coin_f77_comps to see if there's a program that matches one of the names.
     3857# If there's no such program, F77 = unavailable. If we match the name,
     3858# feed AC_PROG_F77 the same search list, just to be sure it's a functioning
     3859# compiler.
     3860# AC_MSG_NOTICE([Fortran compiler candidates: $coin_f77_comps])
     3861
     3862
     3863{ echo "$as_me:$LINENO: Trying to determine Fortran compiler name" >&5
     3864echo "$as_me: Trying to determine Fortran compiler name" >&6;}
     3865for ac_prog in $coin_f77_comps
     3866do
     3867  # Extract the first word of "$ac_prog", so it can be a program name with args.
     3868set dummy $ac_prog; ac_word=$2
     3869echo "$as_me:$LINENO: checking for $ac_word" >&5
     3870echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     3871if test "${ac_cv_prog_F77+set}" = set; then
     3872  echo $ECHO_N "(cached) $ECHO_C" >&6
     3873else
     3874  if test -n "$F77"; then
     3875  ac_cv_prog_F77="$F77" # Let the user override the test.
     3876else
     3877as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3878for as_dir in $PATH
     3879do
     3880  IFS=$as_save_IFS
     3881  test -z "$as_dir" && as_dir=.
     3882  for ac_exec_ext in '' $ac_executable_extensions; do
     3883  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3884    ac_cv_prog_F77="$ac_prog"
     3885    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     3886    break 2
     3887  fi
     3888done
     3889done
     3890
     3891fi
     3892fi
     3893F77=$ac_cv_prog_F77
     3894if test -n "$F77"; then
     3895  echo "$as_me:$LINENO: result: $F77" >&5
     3896echo "${ECHO_T}$F77" >&6
     3897else
     3898  echo "$as_me:$LINENO: result: no" >&5
     3899echo "${ECHO_T}no" >&6
     3900fi
     3901
     3902  test -n "$F77" && break
     3903done
     3904test -n "$F77" || F77="unavailable"
     3905
     3906
     3907if test "$F77" != "unavailable" ; then
     3908  ac_ext=f
     3909ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     3910ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     3911ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     3912if test -n "$ac_tool_prefix"; then
     3913  for ac_prog in $coin_f77_comps
     3914  do
     3915    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     3916set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     3917echo "$as_me:$LINENO: checking for $ac_word" >&5
     3918echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     3919if test "${ac_cv_prog_F77+set}" = set; then
     3920  echo $ECHO_N "(cached) $ECHO_C" >&6
     3921else
     3922  if test -n "$F77"; then
     3923  ac_cv_prog_F77="$F77" # Let the user override the test.
     3924else
     3925as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3926for as_dir in $PATH
     3927do
     3928  IFS=$as_save_IFS
     3929  test -z "$as_dir" && as_dir=.
     3930  for ac_exec_ext in '' $ac_executable_extensions; do
     3931  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3932    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
     3933    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     3934    break 2
     3935  fi
     3936done
     3937done
     3938
     3939fi
     3940fi
     3941F77=$ac_cv_prog_F77
     3942if test -n "$F77"; then
     3943  echo "$as_me:$LINENO: result: $F77" >&5
     3944echo "${ECHO_T}$F77" >&6
     3945else
     3946  echo "$as_me:$LINENO: result: no" >&5
     3947echo "${ECHO_T}no" >&6
     3948fi
     3949
     3950    test -n "$F77" && break
     3951  done
     3952fi
     3953if test -z "$F77"; then
     3954  ac_ct_F77=$F77
     3955  for ac_prog in $coin_f77_comps
     3956do
     3957  # Extract the first word of "$ac_prog", so it can be a program name with args.
     3958set dummy $ac_prog; ac_word=$2
     3959echo "$as_me:$LINENO: checking for $ac_word" >&5
     3960echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     3961if test "${ac_cv_prog_ac_ct_F77+set}" = set; then
     3962  echo $ECHO_N "(cached) $ECHO_C" >&6
     3963else
     3964  if test -n "$ac_ct_F77"; then
     3965  ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.
     3966else
     3967as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3968for as_dir in $PATH
     3969do
     3970  IFS=$as_save_IFS
     3971  test -z "$as_dir" && as_dir=.
     3972  for ac_exec_ext in '' $ac_executable_extensions; do
     3973  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     3974    ac_cv_prog_ac_ct_F77="$ac_prog"
     3975    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     3976    break 2
     3977  fi
     3978done
     3979done
     3980
     3981fi
     3982fi
     3983ac_ct_F77=$ac_cv_prog_ac_ct_F77
     3984if test -n "$ac_ct_F77"; then
     3985  echo "$as_me:$LINENO: result: $ac_ct_F77" >&5
     3986echo "${ECHO_T}$ac_ct_F77" >&6
     3987else
     3988  echo "$as_me:$LINENO: result: no" >&5
     3989echo "${ECHO_T}no" >&6
     3990fi
     3991
     3992  test -n "$ac_ct_F77" && break
     3993done
     3994
     3995  F77=$ac_ct_F77
     3996fi
     3997
     3998
     3999# Provide some information about the compiler.
     4000echo "$as_me:4000:" \
     4001     "checking for Fortran 77 compiler version" >&5
     4002ac_compiler=`set X $ac_compile; echo $2`
     4003{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
     4004  (eval $ac_compiler --version </dev/null >&5) 2>&5
     4005  ac_status=$?
     4006  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4007  (exit $ac_status); }
     4008{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
     4009  (eval $ac_compiler -v </dev/null >&5) 2>&5
     4010  ac_status=$?
     4011  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4012  (exit $ac_status); }
     4013{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
     4014  (eval $ac_compiler -V </dev/null >&5) 2>&5
     4015  ac_status=$?
     4016  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4017  (exit $ac_status); }
     4018rm -f a.out
     4019
     4020# If we don't use `.F' as extension, the preprocessor is not run on the
     4021# input file.  (Note that this only needs to work for GNU compilers.)
     4022ac_save_ext=$ac_ext
     4023ac_ext=F
     4024echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5
     4025echo $ECHO_N "checking whether we are using the GNU Fortran 77 compiler... $ECHO_C" >&6
     4026if test "${ac_cv_f77_compiler_gnu+set}" = set; then
     4027  echo $ECHO_N "(cached) $ECHO_C" >&6
     4028else
     4029  cat >conftest.$ac_ext <<_ACEOF
     4030      program main
     4031#ifndef __GNUC__
     4032       choke me
     4033#endif
     4034
     4035      end
     4036_ACEOF
     4037rm -f conftest.$ac_objext
     4038if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     4039  (eval $ac_compile) 2>conftest.er1
     4040  ac_status=$?
     4041  grep -v '^ *+' conftest.er1 >conftest.err
     4042  rm -f conftest.er1
     4043  cat conftest.err >&5
     4044  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4045  (exit $ac_status); } &&
     4046         { ac_try='test -z "$ac_f77_werror_flag"
     4047                         || test ! -s conftest.err'
     4048  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4049  (eval $ac_try) 2>&5
     4050  ac_status=$?
     4051  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4052  (exit $ac_status); }; } &&
     4053         { ac_try='test -s conftest.$ac_objext'
     4054  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4055  (eval $ac_try) 2>&5
     4056  ac_status=$?
     4057  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4058  (exit $ac_status); }; }; then
     4059  ac_compiler_gnu=yes
     4060else
     4061  echo "$as_me: failed program was:" >&5
     4062sed 's/^/| /' conftest.$ac_ext >&5
     4063
     4064ac_compiler_gnu=no
     4065fi
     4066rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     4067ac_cv_f77_compiler_gnu=$ac_compiler_gnu
     4068
     4069fi
     4070echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5
     4071echo "${ECHO_T}$ac_cv_f77_compiler_gnu" >&6
     4072ac_ext=$ac_save_ext
     4073ac_test_FFLAGS=${FFLAGS+set}
     4074ac_save_FFLAGS=$FFLAGS
     4075FFLAGS=
     4076echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5
     4077echo $ECHO_N "checking whether $F77 accepts -g... $ECHO_C" >&6
     4078if test "${ac_cv_prog_f77_g+set}" = set; then
     4079  echo $ECHO_N "(cached) $ECHO_C" >&6
     4080else
     4081  FFLAGS=-g
     4082cat >conftest.$ac_ext <<_ACEOF
     4083      program main
     4084
     4085      end
     4086_ACEOF
     4087rm -f conftest.$ac_objext
     4088if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     4089  (eval $ac_compile) 2>conftest.er1
     4090  ac_status=$?
     4091  grep -v '^ *+' conftest.er1 >conftest.err
     4092  rm -f conftest.er1
     4093  cat conftest.err >&5
     4094  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4095  (exit $ac_status); } &&
     4096         { ac_try='test -z "$ac_f77_werror_flag"
     4097                         || test ! -s conftest.err'
     4098  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4099  (eval $ac_try) 2>&5
     4100  ac_status=$?
     4101  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4102  (exit $ac_status); }; } &&
     4103         { ac_try='test -s conftest.$ac_objext'
     4104  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4105  (eval $ac_try) 2>&5
     4106  ac_status=$?
     4107  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4108  (exit $ac_status); }; }; then
     4109  ac_cv_prog_f77_g=yes
     4110else
     4111  echo "$as_me: failed program was:" >&5
     4112sed 's/^/| /' conftest.$ac_ext >&5
     4113
     4114ac_cv_prog_f77_g=no
     4115fi
     4116rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     4117
     4118fi
     4119echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5
     4120echo "${ECHO_T}$ac_cv_prog_f77_g" >&6
     4121if test "$ac_test_FFLAGS" = set; then
     4122  FFLAGS=$ac_save_FFLAGS
     4123elif test $ac_cv_prog_f77_g = yes; then
     4124  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
     4125    FFLAGS="-g -O2"
     4126  else
     4127    FFLAGS="-g"
     4128  fi
     4129else
     4130  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
     4131    FFLAGS="-O2"
     4132  else
     4133    FFLAGS=
     4134  fi
     4135fi
     4136
     4137G77=`test $ac_compiler_gnu = yes && echo yes`
     4138ac_ext=f
     4139ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     4140ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4141ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     4142
     4143else
     4144  { echo "$as_me:$LINENO: WARNING: Failed to find a Fortran compiler!" >&5
     4145echo "$as_me: WARNING: Failed to find a Fortran compiler!" >&2;}
     4146fi
     4147
     4148FFLAGS="$save_fflags"
     4149
     4150# Check if a project specific FFLAGS variable has been set
     4151if test x$COIN_PRJCT != x; then
     4152  eval coin_tmp=\${${COIN_PRJCT}_FFLAGS+set}
     4153  if test x$coin_tmp = xset; then
     4154    eval FFLAGS=\${${COIN_PRJCT}_FFLAGS}
     4155  fi
     4156fi
     4157
     4158if test "$F77" != "unavailable" && test x"$FFLAGS" = x ; then
     4159
     4160  coin_add_fflags=
     4161  coin_opt_fflags=
     4162  coin_dbg_fflags=
     4163  coin_warn_fflags=
     4164
     4165  if test "$G77" = "yes"; then
     4166    coin_opt_fflags="-O3 -fomit-frame-pointer"
     4167    coin_add_fflags="-pipe"
     4168    coin_dbg_fflags="-g"
     4169    case $enable_doscompile in
     4170      mingw)
     4171        FFLAGS="-mno-cygwin"
     4172        cat >conftest.$ac_ext <<_ACEOF
     4173      program main
     4174      write(*,*) 'Hello world'
     4175      end
     4176_ACEOF
     4177rm -f conftest.$ac_objext conftest$ac_exeext
     4178if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     4179  (eval $ac_link) 2>conftest.er1
     4180  ac_status=$?
     4181  grep -v '^ *+' conftest.er1 >conftest.err
     4182  rm -f conftest.er1
     4183  cat conftest.err >&5
     4184  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4185  (exit $ac_status); } &&
     4186         { ac_try='test -z "$ac_f77_werror_flag"
     4187                         || test ! -s conftest.err'
     4188  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4189  (eval $ac_try) 2>&5
     4190  ac_status=$?
     4191  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4192  (exit $ac_status); }; } &&
     4193         { ac_try='test -s conftest$ac_exeext'
     4194  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4195  (eval $ac_try) 2>&5
     4196  ac_status=$?
     4197  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4198  (exit $ac_status); }; }; then
     4199  coin_add_fflags="-mno-cygwin $coin_add_fflags"
     4200else
     4201  echo "$as_me: failed program was:" >&5
     4202sed 's/^/| /' conftest.$ac_ext >&5
     4203
     4204fi
     4205rm -f conftest.err conftest.$ac_objext \
     4206      conftest$ac_exeext conftest.$ac_ext
     4207        FFLAGS=
     4208      ;;
     4209    esac
     4210  else
     4211    case $build in
     4212      *-cygwin* | *-mingw*)
     4213        case $F77 in
     4214          ifort* | */ifort* | IFORT* | */IFORT* )
     4215            coin_opt_fflags='-O3'
     4216            coin_add_fflags='-nologo -MT'
     4217            coin_dbg_fflags='-debug'
     4218          ;;
     4219        esac
     4220        ;;
     4221      *-linux-*)
     4222        case $F77 in
     4223          ifc* | */ifc* | ifort* | */ifort*)
     4224            coin_opt_fflags="-O3 -ip"
     4225            coin_add_fflags="-cm -w90 -w95"
     4226            coin_dbg_fflags="-g -CA -CB -CS"
     4227            # Check if -i_dynamic is necessary (for new glibc library)
     4228            FFLAGS=
     4229            cat >conftest.$ac_ext <<_ACEOF
     4230      program main
     4231      write(*,*) 'Hello world'
     4232      end
     4233_ACEOF
     4234rm -f conftest.$ac_objext conftest$ac_exeext
     4235if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     4236  (eval $ac_link) 2>conftest.er1
     4237  ac_status=$?
     4238  grep -v '^ *+' conftest.er1 >conftest.err
     4239  rm -f conftest.er1
     4240  cat conftest.err >&5
     4241  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4242  (exit $ac_status); } &&
     4243         { ac_try='test -z "$ac_f77_werror_flag"
     4244                         || test ! -s conftest.err'
     4245  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4246  (eval $ac_try) 2>&5
     4247  ac_status=$?
     4248  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4249  (exit $ac_status); }; } &&
     4250         { ac_try='test -s conftest$ac_exeext'
     4251  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4252  (eval $ac_try) 2>&5
     4253  ac_status=$?
     4254  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4255  (exit $ac_status); }; }; then
     4256  :
     4257else
     4258  echo "$as_me: failed program was:" >&5
     4259sed 's/^/| /' conftest.$ac_ext >&5
     4260
     4261coin_add_fflags="-i_dynamic $coin_add_fflags"
     4262fi
     4263rm -f conftest.err conftest.$ac_objext \
     4264      conftest$ac_exeext conftest.$ac_ext
     4265            ;;
     4266          pgf77* | */pgf77* | pgf90* | */pgf90*)
     4267            coin_opt_fflags="-fast"
     4268            coin_add_fflags="-Kieee -pc 64"
     4269            coin_dbg_fflags="-g"
     4270          ;;
     4271        esac
     4272        ;;
     4273      *-ibm-*)
     4274        case "$F77" in
     4275          xlf* | */xlf* | mpxlf* | */mpxlf* )
     4276            coin_opt_fflags="-O3 -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
     4277            coin_add_fflags="-bmaxdata:0x80000000"
     4278            coin_dbg_fflags="-g -C"
     4279            ;;
     4280        esac
     4281        ;;
     4282      *-hp-*)
     4283        coin_opt_fflags="+O3"
     4284        coin_add_fflags="+U77"
     4285        coin_dbg_fflags="-C -g"
     4286        ;;
     4287      *-sun-*)
     4288        coin_opt_fflags="-O4"
     4289        coin_dbg_fflags="-g"
     4290        ;;
     4291      *-sgi-*)
     4292        coin_opt_fflags="-O5 -OPT:Olimit=0"
     4293        coin_dbg_fflags="-g"
     4294        ;;
     4295    esac
     4296  fi
     4297
     4298  if test "$ac_cv_prog_f77_g" = yes && test -z "$coin_dbg_fflags" ; then
     4299    coin_dbg_fflags="-g"
     4300  fi
     4301
     4302  if test -z "$coin_opt_fflags"; then
     4303    # Try if -O option works if nothing else is set
     4304    FFLAGS=-O
     4305    cat >conftest.$ac_ext <<_ACEOF
     4306      program main
     4307      integer i
     4308      end
     4309_ACEOF
     4310rm -f conftest.$ac_objext conftest$ac_exeext
     4311if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     4312  (eval $ac_link) 2>conftest.er1
     4313  ac_status=$?
     4314  grep -v '^ *+' conftest.er1 >conftest.err
     4315  rm -f conftest.er1
     4316  cat conftest.err >&5
     4317  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4318  (exit $ac_status); } &&
     4319         { ac_try='test -z "$ac_f77_werror_flag"
     4320                         || test ! -s conftest.err'
     4321  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4322  (eval $ac_try) 2>&5
     4323  ac_status=$?
     4324  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4325  (exit $ac_status); }; } &&
     4326         { ac_try='test -s conftest$ac_exeext'
     4327  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4328  (eval $ac_try) 2>&5
     4329  ac_status=$?
     4330  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4331  (exit $ac_status); }; }; then
     4332  coin_opt_fflags="-O"
     4333else
     4334  echo "$as_me: failed program was:" >&5
     4335sed 's/^/| /' conftest.$ac_ext >&5
     4336
     4337fi
     4338rm -f conftest.err conftest.$ac_objext \
     4339      conftest$ac_exeext conftest.$ac_ext
     4340  fi
     4341
     4342  # if PM doesn't want the warning messages, take them out
     4343  if test x"$coin_skip_warn_fflags" = xyes; then
     4344    coin_warn_fflags=
     4345  fi
     4346
     4347  if test x${DBG_FFLAGS+set} != xset; then
     4348    DBG_FFLAGS="$coin_dbg_fflags $coin_add_fflags $coin_warn_fflags"
     4349  fi
     4350  if test x${OPT_FFLAGS+set} != xset; then
     4351    OPT_FFLAGS="$coin_opt_fflags $coin_add_fflags $coin_warn_fflags"
     4352  fi
     4353
     4354  DBG_FFLAGS="$DBG_FFLAGS $ADD_FFLAGS"
     4355  OPT_FFLAGS="$OPT_FFLAGS $ADD_FFLAGS"
     4356
     4357  if test "$coin_debug_compile" = "true"; then
     4358    FFLAGS="$DBG_FFLAGS"
     4359  else
     4360    FFLAGS="$OPT_FFLAGS"
     4361  fi
     4362else
     4363  FFLAGS="$FFLAGS $ADD_FFLAGS"
     4364  if test x${DBG_FFLAGS+set} != xset; then
     4365    DBG_FFLAGS="$FFLAGS"
     4366  fi
     4367  if test x${OPT_FFLAGS+set} != xset; then
     4368    OPT_FFLAGS="$FFLAGS"
     4369  fi
     4370fi
     4371
     4372# If FFLAGS contains -mno-cygwin, CPPFLAGS must have it.
     4373case "$FFLAGS" in
     4374  *-mno-cygwin*)
     4375    if test x${CPPFLAGS+set} != xset ; then
     4376      CPPFLAGS="-mno-cygwin"
     4377    else
     4378      case "$CPPFLAGS" in
     4379        *-mno-cygwin*)
     4380          ;;
     4381        *)
     4382          CPPFLAGS="$CPPFLAGS -mno-cygwin"
     4383          ;;
     4384      esac
     4385    fi ;;
     4386esac
     4387
     4388# Try if FFLAGS works
     4389if test "$F77" != "unavailable" ; then
     4390  cat >conftest.$ac_ext <<_ACEOF
     4391      program main
     4392      integer i
     4393      end
     4394_ACEOF
     4395rm -f conftest.$ac_objext conftest$ac_exeext
     4396if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     4397  (eval $ac_link) 2>conftest.er1
     4398  ac_status=$?
     4399  grep -v '^ *+' conftest.er1 >conftest.err
     4400  rm -f conftest.er1
     4401  cat conftest.err >&5
     4402  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4403  (exit $ac_status); } &&
     4404         { ac_try='test -z "$ac_f77_werror_flag"
     4405                         || test ! -s conftest.err'
     4406  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4407  (eval $ac_try) 2>&5
     4408  ac_status=$?
     4409  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4410  (exit $ac_status); }; } &&
     4411         { ac_try='test -s conftest$ac_exeext'
     4412  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4413  (eval $ac_try) 2>&5
     4414  ac_status=$?
     4415  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4416  (exit $ac_status); }; }; then
     4417  :
     4418else
     4419  echo "$as_me: failed program was:" >&5
     4420sed 's/^/| /' conftest.$ac_ext >&5
     4421
     4422FFLAGS=
     4423fi
     4424rm -f conftest.err conftest.$ac_objext \
     4425      conftest$ac_exeext conftest.$ac_ext
     4426  if test -z "$FFLAGS"; then
     4427    { echo "$as_me:$LINENO: WARNING: The flags FFLAGS=\"$FFLAGS\" do not work.  I will now just try '-O', but you might want to set FFLAGS manually." >&5
     4428echo "$as_me: WARNING: The flags FFLAGS=\"$FFLAGS\" do not work.  I will now just try '-O', but you might want to set FFLAGS manually." >&2;}
     4429    FFLAGS='-O'
     4430    cat >conftest.$ac_ext <<_ACEOF
     4431      program main
     4432      integer i
     4433      end
     4434_ACEOF
     4435rm -f conftest.$ac_objext conftest$ac_exeext
     4436if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     4437  (eval $ac_link) 2>conftest.er1
     4438  ac_status=$?
     4439  grep -v '^ *+' conftest.er1 >conftest.err
     4440  rm -f conftest.er1
     4441  cat conftest.err >&5
     4442  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4443  (exit $ac_status); } &&
     4444         { ac_try='test -z "$ac_f77_werror_flag"
     4445                         || test ! -s conftest.err'
     4446  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4447  (eval $ac_try) 2>&5
     4448  ac_status=$?
     4449  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4450  (exit $ac_status); }; } &&
     4451         { ac_try='test -s conftest$ac_exeext'
     4452  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     4453  (eval $ac_try) 2>&5
     4454  ac_status=$?
     4455  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     4456  (exit $ac_status); }; }; then
     4457  :
     4458else
     4459  echo "$as_me: failed program was:" >&5
     4460sed 's/^/| /' conftest.$ac_ext >&5
     4461
     4462FFLAGS=
     4463fi
     4464rm -f conftest.err conftest.$ac_objext \
     4465      conftest$ac_exeext conftest.$ac_ext
     4466    if test -z "$FFLAGS"; then
     4467      { echo "$as_me:$LINENO: WARNING: This value for FFLAGS does not work.  I will continue with empty FFLAGS, but you might want to set FFLAGS manually." >&5
     4468echo "$as_me: WARNING: This value for FFLAGS does not work.  I will continue with empty FFLAGS, but you might want to set FFLAGS manually." >&2;}
     4469    fi
     4470  fi
     4471fi
     4472
     4473{ echo "$as_me:$LINENO: Fortran compiler options are: $FFLAGS" >&5
     4474echo "$as_me: Fortran compiler options are: $FFLAGS" >&6;}
     4475
     4476
     4477if test x"$MPIF77" = x; then :; else
     4478  { echo "$as_me:$LINENO: Will use MPI Fortran compiler $MPIF77" >&5
     4479echo "$as_me: Will use MPI Fortran compiler $MPIF77" >&6;}
     4480  F77="$MPIF77"
     4481fi
     4482
     4483case "$F77" in
     4484  ifort* | */ifort* | IFORT* | */IFORT*)
     4485    case $build in
     4486  *-mingw*)
     4487    if test "${LD+set}" = set; then :; else
     4488      LD=link
     4489    fi
     4490    ;;
     4491 esac
     4492 case $enable_doscompile in
     4493   msvc)
     4494     if test "x${LD+set}" = xset; then :; else
     4495       LD=link
     4496     fi
     4497     ;;
     4498 esac
     4499
     4500    ;;
     4501esac
     4502
     4503ac_ext=c
     4504ac_cpp='$CPP $CPPFLAGS'
     4505ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     4506ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     4507ac_compiler_gnu=$ac_cv_c_compiler_gnu
     4508
     4509
     4510
     4511# Initialize automake and libtool
     4512# AC_MSG_NOTICE([Calling INIT_AUTO_TOOLS from CREATE_LIBTOOL.])
     4513{
     4514
     4515
     4516
     4517# START
     4518
     4519# On Cygwin, building DLLs doesn't work
     4520case $build in
     4521  *-cygwin*)
     4522    coin_disable_shared=yes
     4523    platform=Cygwin
     4524  ;;
     4525  *-mingw*)
     4526    coin_disable_shared=yes
     4527    platform="Msys"
     4528#    case "$CXX" in
     4529#      cl*)
     4530#        coin_disable_shared=yes
     4531#        platform="Msys with cl"
     4532#    ;;
     4533#    esac
     4534  ;;
     4535esac
     4536if test x"$coin_disable_shared" = xyes; then
     4537  if test x"$enable_shared" = xyes; then
     4538    { echo "$as_me:$LINENO: WARNING: On $platform, shared objects are not supported. I'm disabling your choice." >&5
     4539echo "$as_me: WARNING: On $platform, shared objects are not supported. I'm disabling your choice." >&2;}
     4540  fi
     4541  enable_shared=no
     4542fi
     4543# By default, we only want the shared objects to be compiled
     4544# Check whether --enable-static or --disable-static was given.
     4545if test "${enable_static+set}" = set; then
     4546  enableval="$enable_static"
     4547  p=${PACKAGE-default}
     4548    case $enableval in
     4549    yes) enable_static=yes ;;
     4550    no) enable_static=no ;;
     4551    *)
     4552     enable_static=no
     4553      # Look at the argument we got.  We use all the common list separators.
     4554      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
     4555      for pkg in $enableval; do
     4556        IFS="$lt_save_ifs"
     4557        if test "X$pkg" = "X$p"; then
     4558          enable_static=yes
     4559        fi
     4560      done
     4561      IFS="$lt_save_ifs"
     4562      ;;
     4563    esac
     4564else
     4565  enable_static=no
     4566fi;
     4567
     4568
     4569
     4570
     4571# Initialize automake
     4572echo "$as_me:$LINENO: checking for egrep" >&5
     4573echo $ECHO_N "checking for egrep... $ECHO_C" >&6
     4574if test "${ac_cv_prog_egrep+set}" = set; then
     4575  echo $ECHO_N "(cached) $ECHO_C" >&6
     4576else
     4577  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
     4578    then ac_cv_prog_egrep='grep -E'
     4579    else ac_cv_prog_egrep='egrep'
     4580    fi
     4581fi
     4582echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
     4583echo "${ECHO_T}$ac_cv_prog_egrep" >&6
     4584 EGREP=$ac_cv_prog_egrep
     4585
     4586
     4587am__api_version="1.9"
    13354588# Find a good install program.  We prefer a C program (faster),
    13364589# so one script is as good as another.  But avoid the broken or
     
    15944847rmdir .tst 2>/dev/null
    15954848
    1596 
     4849DEPDIR="${am__leading_dot}deps"
     4850
     4851          ac_config_commands="$ac_config_commands depfiles"
     4852
     4853
     4854am_make=${MAKE-make}
     4855cat > confinc << 'END'
     4856am__doit:
     4857        @echo done
     4858.PHONY: am__doit
     4859END
     4860# If we don't find an include directive, just comment out the code.
     4861echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
     4862echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
     4863am__include="#"
     4864am__quote=
     4865_am_result=none
     4866# First try GNU make style include.
     4867echo "include confinc" > confmf
     4868# We grep out `Entering directory' and `Leaving directory'
     4869# messages which can occur if `w' ends up in MAKEFLAGS.
     4870# In particular we don't look at `^make:' because GNU make might
     4871# be invoked under some other name (usually "gmake"), in which
     4872# case it prints its new name instead of `make'.
     4873if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
     4874   am__include=include
     4875   am__quote=
     4876   _am_result=GNU
     4877fi
     4878# Now try BSD make style include.
     4879if test "$am__include" = "#"; then
     4880   echo '.include "confinc"' > confmf
     4881   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
     4882      am__include=.include
     4883      am__quote="\""
     4884      _am_result=BSD
     4885   fi
     4886fi
     4887
     4888
     4889echo "$as_me:$LINENO: result: $_am_result" >&5
     4890echo "${ECHO_T}$_am_result" >&6
     4891rm -f confinc confmf
     4892
     4893# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
     4894if test "${enable_dependency_tracking+set}" = set; then
     4895  enableval="$enable_dependency_tracking"
     4896
     4897fi;
     4898if test "x$enable_dependency_tracking" != xno; then
     4899  am_depcomp="$ac_aux_dir/depcomp"
     4900  AMDEPBACKSLASH='\'
     4901fi
     4902
     4903
     4904if test "x$enable_dependency_tracking" != xno; then
     4905  AMDEP_TRUE=
     4906  AMDEP_FALSE='#'
     4907else
     4908  AMDEP_TRUE='#'
     4909  AMDEP_FALSE=
     4910fi
     4911
     4912
     4913
     4914
     4915
     4916# AC_MSG_NOTICE([Beginning automake initialisation.])
    15974917# Stuff for automake
    15984918# test to see if srcdir already configured
     
    17455065
    17465066
     5067depcc="$CC"   am_compiler_list=
     5068
     5069echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
     5070echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
     5071if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
     5072  echo $ECHO_N "(cached) $ECHO_C" >&6
     5073else
     5074  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
     5075  # We make a subdir and do the tests there.  Otherwise we can end up
     5076  # making bogus files that we don't know about and never remove.  For
     5077  # instance it was reported that on HP-UX the gcc test will end up
     5078  # making a dummy file named `D' -- because `-MD' means `put the output
     5079  # in D'.
     5080  mkdir conftest.dir
     5081  # Copy depcomp to subdir because otherwise we won't find it if we're
     5082  # using a relative directory.
     5083  cp "$am_depcomp" conftest.dir
     5084  cd conftest.dir
     5085  # We will build objects and dependencies in a subdirectory because
     5086  # it helps to detect inapplicable dependency modes.  For instance
     5087  # both Tru64's cc and ICC support -MD to output dependencies as a
     5088  # side effect of compilation, but ICC will put the dependencies in
     5089  # the current directory while Tru64 will put them in the object
     5090  # directory.
     5091  mkdir sub
     5092
     5093  am_cv_CC_dependencies_compiler_type=none
     5094  if test "$am_compiler_list" = ""; then
     5095     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
     5096  fi
     5097  for depmode in $am_compiler_list; do
     5098    # Setup a source with many dependencies, because some compilers
     5099    # like to wrap large dependency lists on column 80 (with \), and
     5100    # we should not choose a depcomp mode which is confused by this.
     5101    #
     5102    # We need to recreate these files for each test, as the compiler may
     5103    # overwrite some of them when testing with obscure command lines.
     5104    # This happens at least with the AIX C compiler.
     5105    : > sub/conftest.c
     5106    for i in 1 2 3 4 5 6; do
     5107      echo '#include "conftst'$i'.h"' >> sub/conftest.c
     5108      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
     5109      # Solaris 8's {/usr,}/bin/sh.
     5110      touch sub/conftst$i.h
     5111    done
     5112    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
     5113
     5114    case $depmode in
     5115    nosideeffect)
     5116      # after this tag, mechanisms are not by side-effect, so they'll
     5117      # only be used when explicitly requested
     5118      if test "x$enable_dependency_tracking" = xyes; then
     5119        continue
     5120      else
     5121        break
     5122      fi
     5123      ;;
     5124    none) break ;;
     5125    esac
     5126    # We check with `-c' and `-o' for the sake of the "dashmstdout"
     5127    # mode.  It turns out that the SunPro C++ compiler does not properly
     5128    # handle `-M -o', and we need to detect this.
     5129    if depmode=$depmode \
     5130       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
     5131       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
     5132       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
     5133         >/dev/null 2>conftest.err &&
     5134       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
     5135       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
     5136       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
     5137      # icc doesn't choke on unknown options, it will just issue warnings
     5138      # or remarks (even with -Werror).  So we grep stderr for any message
     5139      # that says an option was ignored or not supported.
     5140      # When given -MP, icc 7.0 and 7.1 complain thusly:
     5141      #   icc: Command line warning: ignoring option '-M'; no argument required
     5142      # The diagnosis changed in icc 8.0:
     5143      #   icc: Command line remark: option '-MP' not supported
     5144      if (grep 'ignoring option' conftest.err ||
     5145          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
     5146        am_cv_CC_dependencies_compiler_type=$depmode
     5147        break
     5148      fi
     5149    fi
     5150  done
     5151
     5152  cd ..
     5153  rm -rf conftest.dir
     5154else
     5155  am_cv_CC_dependencies_compiler_type=none
     5156fi
     5157
     5158fi
     5159echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
     5160echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
     5161CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
     5162
     5163
     5164
     5165if
     5166  test "x$enable_dependency_tracking" != xno \
     5167  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
     5168  am__fastdepCC_TRUE=
     5169  am__fastdepCC_FALSE='#'
     5170else
     5171  am__fastdepCC_TRUE='#'
     5172  am__fastdepCC_FALSE=
     5173fi
     5174
     5175
     5176depcc="$CXX"  am_compiler_list=
     5177
     5178echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
     5179echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
     5180if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then
     5181  echo $ECHO_N "(cached) $ECHO_C" >&6
     5182else
     5183  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
     5184  # We make a subdir and do the tests there.  Otherwise we can end up
     5185  # making bogus files that we don't know about and never remove.  For
     5186  # instance it was reported that on HP-UX the gcc test will end up
     5187  # making a dummy file named `D' -- because `-MD' means `put the output
     5188  # in D'.
     5189  mkdir conftest.dir
     5190  # Copy depcomp to subdir because otherwise we won't find it if we're
     5191  # using a relative directory.
     5192  cp "$am_depcomp" conftest.dir
     5193  cd conftest.dir
     5194  # We will build objects and dependencies in a subdirectory because
     5195  # it helps to detect inapplicable dependency modes.  For instance
     5196  # both Tru64's cc and ICC support -MD to output dependencies as a
     5197  # side effect of compilation, but ICC will put the dependencies in
     5198  # the current directory while Tru64 will put them in the object
     5199  # directory.
     5200  mkdir sub
     5201
     5202  am_cv_CXX_dependencies_compiler_type=none
     5203  if test "$am_compiler_list" = ""; then
     5204     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
     5205  fi
     5206  for depmode in $am_compiler_list; do
     5207    # Setup a source with many dependencies, because some compilers
     5208    # like to wrap large dependency lists on column 80 (with \), and
     5209    # we should not choose a depcomp mode which is confused by this.
     5210    #
     5211    # We need to recreate these files for each test, as the compiler may
     5212    # overwrite some of them when testing with obscure command lines.
     5213    # This happens at least with the AIX C compiler.
     5214    : > sub/conftest.c
     5215    for i in 1 2 3 4 5 6; do
     5216      echo '#include "conftst'$i'.h"' >> sub/conftest.c
     5217      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
     5218      # Solaris 8's {/usr,}/bin/sh.
     5219      touch sub/conftst$i.h
     5220    done
     5221    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
     5222
     5223    case $depmode in
     5224    nosideeffect)
     5225      # after this tag, mechanisms are not by side-effect, so they'll
     5226      # only be used when explicitly requested
     5227      if test "x$enable_dependency_tracking" = xyes; then
     5228        continue
     5229      else
     5230        break
     5231      fi
     5232      ;;
     5233    none) break ;;
     5234    esac
     5235    # We check with `-c' and `-o' for the sake of the "dashmstdout"
     5236    # mode.  It turns out that the SunPro C++ compiler does not properly
     5237    # handle `-M -o', and we need to detect this.
     5238    if depmode=$depmode \
     5239       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
     5240       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
     5241       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
     5242         >/dev/null 2>conftest.err &&
     5243       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
     5244       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
     5245       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
     5246      # icc doesn't choke on unknown options, it will just issue warnings
     5247      # or remarks (even with -Werror).  So we grep stderr for any message
     5248      # that says an option was ignored or not supported.
     5249      # When given -MP, icc 7.0 and 7.1 complain thusly:
     5250      #   icc: Command line warning: ignoring option '-M'; no argument required
     5251      # The diagnosis changed in icc 8.0:
     5252      #   icc: Command line remark: option '-MP' not supported
     5253      if (grep 'ignoring option' conftest.err ||
     5254          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
     5255        am_cv_CXX_dependencies_compiler_type=$depmode
     5256        break
     5257      fi
     5258    fi
     5259  done
     5260
     5261  cd ..
     5262  rm -rf conftest.dir
     5263else
     5264  am_cv_CXX_dependencies_compiler_type=none
     5265fi
     5266
     5267fi
     5268echo "$as_me:$LINENO: result: $am_cv_CXX_dependencies_compiler_type" >&5
     5269echo "${ECHO_T}$am_cv_CXX_dependencies_compiler_type" >&6
     5270CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
     5271
     5272
     5273
     5274if
     5275  test "x$enable_dependency_tracking" != xno \
     5276  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
     5277  am__fastdepCXX_TRUE=
     5278  am__fastdepCXX_FALSE='#'
     5279else
     5280  am__fastdepCXX_TRUE='#'
     5281  am__fastdepCXX_FALSE=
     5282fi
     5283
     5284
    17475285
    17485286echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
     
    17755313
    17765314  # If maintainer mode is chosen, we make sure that the correct versions
    1777   # of the tools are used, and that we know where libtoo.m4 is (to
     5315  # of the tools are used, and that we know where libtool.m4 is (to
    17785316  # recreate acinclude.m4)
    17795317
    17805318
    17815319  LIBTOOLM4=
    1782 
    1783   # Check if we have autoconf
    1784   # Extract the first word of "autoconf", so it can be a program name with args.
     5320  # Normally, $HOME
     5321  AUTOTOOLS_DFLT=$HOME
     5322
     5323  echo "$as_me:$LINENO: checking whether we are using the correct autotools" >&5
     5324echo $ECHO_N "checking whether we are using the correct autotools... $ECHO_C" >&6
     5325if test "${ac_cv_use_correct_autotools+set}" = set; then
     5326  echo $ECHO_N "(cached) $ECHO_C" >&6
     5327else
     5328  ac_cv_use_correct_autotools=check
     5329fi
     5330echo "$as_me:$LINENO: result: $ac_cv_use_correct_autotools" >&5
     5331echo "${ECHO_T}$ac_cv_use_correct_autotools" >&6
     5332
     5333  if test $ac_cv_use_correct_autotools = check; then
     5334    ac_cv_use_correct_autotools=yes
     5335    # Check if we have autoconf
     5336    # Extract the first word of "autoconf", so it can be a program name with args.
    17855337set dummy autoconf; ac_word=$2
    17865338echo "$as_me:$LINENO: checking for $ac_word" >&5
     
    18185370fi
    18195371
    1820   if test $have_autoconf = no; then
    1821     { { echo "$as_me:$LINENO: error: You specified you want to use maintainer mode, but I cannot find autoconf in your path." >&5
     5372    if test $have_autoconf = no; then
     5373      { { echo "$as_me:$LINENO: error: You specified you want to use maintainer mode, but I cannot find autoconf in your path." >&5
    18225374echo "$as_me: error: You specified you want to use maintainer mode, but I cannot find autoconf in your path." >&2;}
    18235375   { (exit 1); exit 1; }; }
    1824   fi
    1825 
    1826   # Check whether autoconf is the correct version
    1827   correct_version='2.59'
    1828   grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
    1829   echo "$as_me:$LINENO: checking whether we are using the correct version ($correct_version) of autoconf" >&5
     5376    fi
     5377
     5378    # Check whether autoconf is the correct version
     5379    correct_version='2.59'
     5380    grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
     5381    echo "$as_me:$LINENO: checking whether we are using the correct version ($correct_version) of autoconf" >&5
    18305382echo $ECHO_N "checking whether we are using the correct version ($correct_version) of autoconf... $ECHO_C" >&6
    1831   autoconf --version > confauto.out 2>&1
    1832   if $EGREP $grep_version confauto.out >/dev/null 2>&1; then
    1833     echo "$as_me:$LINENO: result: yes" >&5
     5383    autoconf --version > confauto.out 2>&1
     5384    if $EGREP $grep_version confauto.out >/dev/null 2>&1; then
     5385      echo "$as_me:$LINENO: result: yes" >&5
    18345386echo "${ECHO_T}yes" >&6
    1835   else
    1836     rm -f confauto.out
    1837     echo "$as_me:$LINENO: result: no" >&5
     5387    else
     5388      rm -f confauto.out
     5389      echo "$as_me:$LINENO: result: no" >&5
    18385390echo "${ECHO_T}no" >&6
    1839     { { echo "$as_me:$LINENO: error: You don't have the correct version of autoconf as the first one in your path." >&5
     5391      { { echo "$as_me:$LINENO: error: You don't have the correct version of autoconf as the first one in your path." >&5
    18405392echo "$as_me: error: You don't have the correct version of autoconf as the first one in your path." >&2;}
    18415393   { (exit 1); exit 1; }; }
    1842   fi
    1843   rm -f confauto.out
    1844 
    1845   # Check if the executable autoconf is picked up from the correct location
    1846   echo "$as_me:$LINENO: checking whether autoconf is coming from the correct location" >&5
     5394    fi
     5395    rm -f confauto.out
     5396
     5397    # Check if the executable autoconf is picked up from the correct location
     5398    echo "$as_me:$LINENO: checking whether autoconf is coming from the correct location" >&5
    18475399echo $ECHO_N "checking whether autoconf is coming from the correct location... $ECHO_C" >&6
    1848   autoconf_dir=`which autoconf | sed -e 's=/autoconf=='`
    1849   autoconf_dir=`cd $autoconf_dir; pwd`
    1850   if test x$AUTOTOOLS_DIR = x; then
    1851     want_dir=$HOME/bin
    1852   else
    1853     want_dir=$AUTOTOOLS_DIR/bin
    1854   fi
    1855   if test $autoconf_dir = `cd $want_dir; pwd`; then
    1856     echo "$as_me:$LINENO: result: yes" >&5
     5400    autoconf_dir=`which autoconf | sed -e 's=/autoconf=='`
     5401    autoconf_dir=`cd $autoconf_dir; pwd`
     5402    if test x$AUTOTOOLS_DIR = x; then
     5403      want_dir=$AUTOTOOLS_DFLT/bin
     5404    else
     5405      want_dir=$AUTOTOOLS_DIR/bin
     5406    fi
     5407    if test $autoconf_dir = `cd $want_dir; pwd`; then
     5408      echo "$as_me:$LINENO: result: yes" >&5
    18575409echo "${ECHO_T}yes" >&6
    1858   else
    1859     rm -f confauto.out
    1860     echo "$as_me:$LINENO: result: no" >&5
     5410    else
     5411      rm -f confauto.out
     5412      echo "$as_me:$LINENO: result: no" >&5
    18615413echo "${ECHO_T}no" >&6
    1862     { { echo "$as_me:$LINENO: error: The autoconf executable should be picked up from \$HOME/bin or \$AUTOTOOLS_DIR/bin." >&5
    1863 echo "$as_me: error: The autoconf executable should be picked up from \$HOME/bin or \$AUTOTOOLS_DIR/bin." >&2;}
     5414      { { echo "$as_me:$LINENO: error: The autoconf executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin." >&5
     5415echo "$as_me: error: The autoconf executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin." >&2;}
    18645416   { (exit 1); exit 1; }; }
    1865   fi
    1866 
    1867   # Check if we have automake
    1868   # Extract the first word of "automake", so it can be a program name with args.
     5417    fi
     5418
     5419    # Check if we have automake
     5420    # Extract the first word of "automake", so it can be a program name with args.
    18695421set dummy automake; ac_word=$2
    18705422echo "$as_me:$LINENO: checking for $ac_word" >&5
     
    19025454fi
    19035455
    1904   if test $have_automake = no; then
    1905     { { echo "$as_me:$LINENO: error: You specified you want to use maintainer mode, but I cannot find automake in your path." >&5
     5456    if test $have_automake = no; then
     5457      { { echo "$as_me:$LINENO: error: You specified you want to use maintainer mode, but I cannot find automake in your path." >&5
    19065458echo "$as_me: error: You specified you want to use maintainer mode, but I cannot find automake in your path." >&2;}
    19075459   { (exit 1); exit 1; }; }
    1908   fi
    1909 
    1910   # Check whether automake is the correct version
    1911   correct_version='1.9.6'
    1912   grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
    1913   echo "$as_me:$LINENO: checking whether we are using the correct version ($correct_version) of automake" >&5
     5460    fi
     5461
     5462    # Check whether automake is the correct version
     5463    correct_version='1.9.6'
     5464    grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
     5465    echo "$as_me:$LINENO: checking whether we are using the correct version ($correct_version) of automake" >&5
    19145466echo $ECHO_N "checking whether we are using the correct version ($correct_version) of automake... $ECHO_C" >&6
    1915   automake --version > confauto.out 2>&1
    1916   if $EGREP $grep_version confauto.out >/dev/null 2>&1; then
    1917     echo "$as_me:$LINENO: result: yes" >&5
     5467    automake --version > confauto.out 2>&1
     5468    if $EGREP $grep_version confauto.out >/dev/null 2>&1; then
     5469      echo "$as_me:$LINENO: result: yes" >&5
    19185470echo "${ECHO_T}yes" >&6
    1919   else
    1920     rm -f confauto.out
    1921     echo "$as_me:$LINENO: result: no" >&5
     5471    else
     5472      rm -f confauto.out
     5473      echo "$as_me:$LINENO: result: no" >&5
    19225474echo "${ECHO_T}no" >&6
    1923     { { echo "$as_me:$LINENO: error: You don't have the correct version of automake as the first one in your path." >&5
     5475      { { echo "$as_me:$LINENO: error: You don't have the correct version of automake as the first one in your path." >&5
    19245476echo "$as_me: error: You don't have the correct version of automake as the first one in your path." >&2;}
    19255477   { (exit 1); exit 1; }; }
    1926   fi
    1927   rm -f confauto.out
    1928 
    1929   # Check if the executable automake is picked up from the correct location
    1930   echo "$as_me:$LINENO: checking whether automake is coming from the correct location" >&5
     5478    fi
     5479    rm -f confauto.out
     5480
     5481    # Check if the executable automake is picked up from the correct location
     5482    echo "$as_me:$LINENO: checking whether automake is coming from the correct location" >&5
    19315483echo $ECHO_N "checking whether automake is coming from the correct location... $ECHO_C" >&6
    1932   automake_dir=`which automake | sed -e 's=/automake=='`
    1933   automake_dir=`cd $automake_dir; pwd`
    1934   if test x$AUTOTOOLS_DIR = x; then
    1935     want_dir=$HOME/bin
    1936   else
    1937     want_dir=$AUTOTOOLS_DIR/bin
    1938   fi
    1939   if test $automake_dir = `cd $want_dir; pwd`; then
    1940     echo "$as_me:$LINENO: result: yes" >&5
     5484    automake_dir=`which automake | sed -e 's=/automake=='`
     5485    automake_dir=`cd $automake_dir; pwd`
     5486    if test x$AUTOTOOLS_DIR = x; then
     5487      want_dir=$AUTOTOOLS_DFLT/bin
     5488    else
     5489      want_dir=$AUTOTOOLS_DIR/bin
     5490    fi
     5491    if test $automake_dir = `cd $want_dir; pwd`; then
     5492      echo "$as_me:$LINENO: result: yes" >&5
    19415493echo "${ECHO_T}yes" >&6
    1942   else
    1943     rm -f confauto.out
    1944     echo "$as_me:$LINENO: result: no" >&5
     5494    else
     5495      rm -f confauto.out
     5496      echo "$as_me:$LINENO: result: no" >&5
    19455497echo "${ECHO_T}no" >&6
    1946     { { echo "$as_me:$LINENO: error: The automake executable should be picked up from \$HOME/bin or \$AUTOTOOLS_DIR/bin." >&5
    1947 echo "$as_me: error: The automake executable should be picked up from \$HOME/bin or \$AUTOTOOLS_DIR/bin." >&2;}
     5498      { { echo "$as_me:$LINENO: error: The automake executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin." >&5
     5499echo "$as_me: error: The automake executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin." >&2;}
    19485500   { (exit 1); exit 1; }; }
     5501    fi
     5502
     5503    # Check if this is the correct version of libtool (with escaped dots)
     5504    if test x$AUTOTOOLS_DIR = x; then
     5505      want_dir=$AUTOTOOLS_DFLT/share
     5506    else
     5507      want_dir=$AUTOTOOLS_DIR/share
     5508    fi
     5509    correct_version='1.5.22'
     5510    grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
     5511    as_ac_File=`echo "ac_cv_file_$want_dir/libtool/ltmain.sh" | $as_tr_sh`
     5512echo "$as_me:$LINENO: checking for $want_dir/libtool/ltmain.sh" >&5
     5513echo $ECHO_N "checking for $want_dir/libtool/ltmain.sh... $ECHO_C" >&6
     5514if eval "test \"\${$as_ac_File+set}\" = set"; then
     5515  echo $ECHO_N "(cached) $ECHO_C" >&6
     5516else
     5517  test "$cross_compiling" = yes &&
     5518  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
     5519echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
     5520   { (exit 1); exit 1; }; }
     5521if test -r "$want_dir/libtool/ltmain.sh"; then
     5522  eval "$as_ac_File=yes"
     5523else
     5524  eval "$as_ac_File=no"
     5525fi
     5526fi
     5527echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_File'}'`" >&5
     5528echo "${ECHO_T}`eval echo '${'$as_ac_File'}'`" >&6
     5529if test `eval echo '${'$as_ac_File'}'` = yes; then
     5530  have_ltmain=yes
     5531else
     5532  have_ltmain=no
     5533fi
     5534
     5535    echo "$as_me:$LINENO: checking whether we are using the correct version ($correct_version) of libtool." >&5
     5536echo $ECHO_N "checking whether we are using the correct version ($correct_version) of libtool.... $ECHO_C" >&6
     5537    if test $have_ltmain = yes; then
     5538    if $EGREP $grep_version $want_dir/libtool/ltmain.sh >/dev/null 2>&1; then
     5539        echo "$as_me:$LINENO: result: yes" >&5
     5540echo "${ECHO_T}yes" >&6
     5541      else
     5542        echo "$as_me:$LINENO: result: no" >&5
     5543echo "${ECHO_T}no" >&6
     5544        { { echo "$as_me:$LINENO: error: You don't have the correct version of libtool." >&5
     5545echo "$as_me: error: You don't have the correct version of libtool." >&2;}
     5546   { (exit 1); exit 1; }; }
     5547      fi
     5548    else
     5549      echo "$as_me:$LINENO: result: no" >&5
     5550echo "${ECHO_T}no" >&6
     5551      { { echo "$as_me:$LINENO: error: I cannot find the ltmain.sh file." >&5
     5552echo "$as_me: error: I cannot find the ltmain.sh file." >&2;}
     5553   { (exit 1); exit 1; }; }
     5554    fi
    19495555  fi
    19505556
    19515557  # Check if we can find the libtool file
    19525558  if test x$AUTOTOOLS_DIR = x; then
    1953     want_dir=$HOME/share
     5559    want_dir=$AUTOTOOLS_DFLT/share
    19545560  else
    19555561    want_dir=$AUTOTOOLS_DIR/share
     
    19815587fi
    19825588
    1983 
    1984   # Check if this is the correct version of libtool (with escaped dots)
    1985   correct_version='1.5.22'
    1986   grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
    1987   as_ac_File=`echo "ac_cv_file_$want_dir/libtool/ltmain.sh" | $as_tr_sh`
    1988 echo "$as_me:$LINENO: checking for $want_dir/libtool/ltmain.sh" >&5
    1989 echo $ECHO_N "checking for $want_dir/libtool/ltmain.sh... $ECHO_C" >&6
    1990 if eval "test \"\${$as_ac_File+set}\" = set"; then
    1991   echo $ECHO_N "(cached) $ECHO_C" >&6
    1992 else
    1993   test "$cross_compiling" = yes &&
    1994   { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
    1995 echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
    1996    { (exit 1); exit 1; }; }
    1997 if test -r "$want_dir/libtool/ltmain.sh"; then
    1998   eval "$as_ac_File=yes"
    1999 else
    2000   eval "$as_ac_File=no"
    2001 fi
    2002 fi
    2003 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_File'}'`" >&5
    2004 echo "${ECHO_T}`eval echo '${'$as_ac_File'}'`" >&6
    2005 if test `eval echo '${'$as_ac_File'}'` = yes; then
    2006   have_ltmain=yes
    2007 else
    2008   have_ltmain=no
    2009 fi
    2010 
    2011   echo "$as_me:$LINENO: checking whether we are using the correct version ($correct_version) of libtool." >&5
    2012 echo $ECHO_N "checking whether we are using the correct version ($correct_version) of libtool.... $ECHO_C" >&6
    2013   if test $have_ltmain = yes; then
    2014     if $EGREP $grep_version $want_dir/libtool/ltmain.sh >/dev/null 2>&1; then
    2015       echo "$as_me:$LINENO: result: yes" >&5
    2016 echo "${ECHO_T}yes" >&6
    2017     else
    2018       echo "$as_me:$LINENO: result: no" >&5
    2019 echo "${ECHO_T}no" >&6
    2020       { { echo "$as_me:$LINENO: error: You don't have the correct version of libtool." >&5
    2021 echo "$as_me: error: You don't have the correct version of libtool." >&2;}
    2022    { (exit 1); exit 1; }; }
    2023     fi
    2024   else
    2025     echo "$as_me:$LINENO: result: no" >&5
    2026 echo "${ECHO_T}no" >&6
    2027     { { echo "$as_me:$LINENO: error: I cannot find the ltmain.sh file." >&5
    2028 echo "$as_me: error: I cannot find the ltmain.sh file." >&2;}
    2029    { (exit 1); exit 1; }; }
    2030   fi
    20315589
    20325590  # Check if we have an Externals file
     
    20725630
    20735631  if test x$have_svn = xyes; then
    2074     echo "$as_me:$LINENO: checking svn understands https" >&5
    2075 echo $ECHO_N "checking svn understands https... $ECHO_C" >&6
    2076     svn --version > confauto.out 2>&1
    2077     if $EGREP https confauto.out >/dev/null 2>&1; then
    2078       echo "$as_me:$LINENO: result: yes" >&5
    2079 echo "${ECHO_T}yes" >&6
    2080     else
    2081       echo "$as_me:$LINENO: result: no" >&5
    2082 echo "${ECHO_T}no" >&6
    2083       have_svn=no
    2084     fi
    2085     rm -f confauto.out
     5632    echo "$as_me:$LINENO: checking whether svn understands https" >&5
     5633echo $ECHO_N "checking whether svn understands https... $ECHO_C" >&6
     5634if test "${ac_cv_svn_understands_https+set}" = set; then
     5635  echo $ECHO_N "(cached) $ECHO_C" >&6
     5636else
     5637  svn --version > confauto.out 2>&1
     5638                    if $EGREP https confauto.out >/dev/null 2>&1; then
     5639                      ac_cv_svn_understands_https=yes
     5640                    else
     5641                      ac_cv_svn_understands_https=no
     5642                      have_svn=no
     5643                      ac_cv_prog_have_svn=no
     5644                    fi
     5645                    rm -f confauto.out
     5646fi
     5647echo "$as_me:$LINENO: result: $ac_cv_svn_understands_https" >&5
     5648echo "${ECHO_T}$ac_cv_svn_understands_https" >&6
    20865649  fi
    20875650
     
    21405703
    21415704
     5705# AC_MSG_NOTICE([End automake initialisation.])
     5706
     5707
     5708
     5709unset ac_cv_file__________libtool
     5710unset ac_cv_file_______libtool
     5711unset ac_cv_file____libtool
     5712
     5713LIBTOOL=
     5714echo "$as_me:$LINENO: checking for ../libtool" >&5
     5715echo $ECHO_N "checking for ../libtool... $ECHO_C" >&6
     5716if test "${ac_cv_file____libtool+set}" = set; then
     5717  echo $ECHO_N "(cached) $ECHO_C" >&6
     5718else
     5719  test "$cross_compiling" = yes &&
     5720  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
     5721echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
     5722   { (exit 1); exit 1; }; }
     5723if test -r "../libtool"; then
     5724  ac_cv_file____libtool=yes
     5725else
     5726  ac_cv_file____libtool=no
     5727fi
     5728fi
     5729echo "$as_me:$LINENO: result: $ac_cv_file____libtool" >&5
     5730echo "${ECHO_T}$ac_cv_file____libtool" >&6
     5731if test $ac_cv_file____libtool = yes; then
     5732  coin_config_dir=..
     5733               LIBTOOL='$(SHELL) $(top_builddir)/../libtool'
     5734fi
     5735
     5736if test "x$LIBTOOL" = x; then
     5737  echo "$as_me:$LINENO: checking for ../../libtool" >&5
     5738echo $ECHO_N "checking for ../../libtool... $ECHO_C" >&6
     5739if test "${ac_cv_file_______libtool+set}" = set; then
     5740  echo $ECHO_N "(cached) $ECHO_C" >&6
     5741else
     5742  test "$cross_compiling" = yes &&
     5743  { { echo "$as_me:$LINENO: error: cannot check for file existence when cross compiling" >&5
     5744echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
     5745   { (exit 1); exit 1; }; }
     5746if test -r "../../libtool"; then
     5747  ac_cv_file_______libtool=yes
     5748else
     5749  ac_cv_file_______libtool=no
     5750fi
     5751fi
     5752echo "$as_me:$LINENO: result: $ac_cv_file_______libtool" >&5
     5753echo "${ECHO_T}$ac_cv_file_______libtool" >&6
     5754if test $ac_cv_file_______libtool = yes; then
     5755  coin_config_dir=../..
     5756                 LIBTOOL='$(SHELL) $(top_builddir)/../../libtool'
     5757fi
     5758
     5759fi
     5760# if test "x$LIBTOOL" = x; then
     5761#   AC_CHECK_FILE([../../../libtool],
     5762#                 [coin_config_dir=../../..
     5763#                  LIBTOOL='$(SHELL) $(top_builddir)/../../../libtool'])
     5764# fi
     5765
     5766if test "x$LIBTOOL" = x; then
     5767# AC_MSG_NOTICE([Creating libtool script (calling COIN_PROG_LIBTOOL).])
     5768  # Stuff for libtool
     5769  # Check whether --enable-shared or --disable-shared was given.
     5770if test "${enable_shared+set}" = set; then
     5771  enableval="$enable_shared"
     5772  p=${PACKAGE-default}
     5773    case $enableval in
     5774    yes) enable_shared=yes ;;
     5775    no) enable_shared=no ;;
     5776    *)
     5777      enable_shared=no
     5778      # Look at the argument we got.  We use all the common list separators.
     5779      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
     5780      for pkg in $enableval; do
     5781        IFS="$lt_save_ifs"
     5782        if test "X$pkg" = "X$p"; then
     5783          enable_shared=yes
     5784        fi
     5785      done
     5786      IFS="$lt_save_ifs"
     5787      ;;
     5788    esac
     5789else
     5790  enable_shared=yes
     5791fi;
     5792
     5793# Check whether --enable-fast-install or --disable-fast-install was given.
     5794if test "${enable_fast_install+set}" = set; then
     5795  enableval="$enable_fast_install"
     5796  p=${PACKAGE-default}
     5797    case $enableval in
     5798    yes) enable_fast_install=yes ;;
     5799    no) enable_fast_install=no ;;
     5800    *)
     5801      enable_fast_install=no
     5802      # Look at the argument we got.  We use all the common list separators.
     5803      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
     5804      for pkg in $enableval; do
     5805        IFS="$lt_save_ifs"
     5806        if test "X$pkg" = "X$p"; then
     5807          enable_fast_install=yes
     5808        fi
     5809      done
     5810      IFS="$lt_save_ifs"
     5811      ;;
     5812    esac
     5813else
     5814  enable_fast_install=yes
     5815fi;
     5816
     5817echo "$as_me:$LINENO: checking host system type" >&5
     5818echo $ECHO_N "checking host system type... $ECHO_C" >&6
     5819if test "${ac_cv_host+set}" = set; then
     5820  echo $ECHO_N "(cached) $ECHO_C" >&6
     5821else
     5822  ac_cv_host_alias=$host_alias
     5823test -z "$ac_cv_host_alias" &&
     5824  ac_cv_host_alias=$ac_cv_build_alias
     5825ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
     5826  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
     5827echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
     5828   { (exit 1); exit 1; }; }
     5829
     5830fi
     5831echo "$as_me:$LINENO: result: $ac_cv_host" >&5
     5832echo "${ECHO_T}$ac_cv_host" >&6
     5833host=$ac_cv_host
     5834host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
     5835host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
     5836host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
     5837
     5838
     5839echo "$as_me:$LINENO: checking for a sed that does not truncate output" >&5
     5840echo $ECHO_N "checking for a sed that does not truncate output... $ECHO_C" >&6
     5841if test "${lt_cv_path_SED+set}" = set; then
     5842  echo $ECHO_N "(cached) $ECHO_C" >&6
     5843else
     5844  # Loop through the user's path and test for sed and gsed.
     5845# Then use that list of sed's as ones to test for truncation.
     5846as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     5847for as_dir in $PATH
     5848do
     5849  IFS=$as_save_IFS
     5850  test -z "$as_dir" && as_dir=.
     5851  for lt_ac_prog in sed gsed; do
     5852    for ac_exec_ext in '' $ac_executable_extensions; do
     5853      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
     5854        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
     5855      fi
     5856    done
     5857  done
     5858done
     5859lt_ac_max=0
     5860lt_ac_count=0
     5861# Add /usr/xpg4/bin/sed as it is typically found on Solaris
     5862# along with /bin/sed that truncates output.
     5863for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
     5864  test ! -f $lt_ac_sed && continue
     5865  cat /dev/null > conftest.in
     5866  lt_ac_count=0
     5867  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
     5868  # Check for GNU sed and select it if it is found.
     5869  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
     5870    lt_cv_path_SED=$lt_ac_sed
     5871    break
     5872  fi
     5873  while true; do
     5874    cat conftest.in conftest.in >conftest.tmp
     5875    mv conftest.tmp conftest.in
     5876    cp conftest.in conftest.nl
     5877    echo >>conftest.nl
     5878    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
     5879    cmp -s conftest.out conftest.nl || break
     5880    # 10000 chars as input seems more than enough
     5881    test $lt_ac_count -gt 10 && break
     5882    lt_ac_count=`expr $lt_ac_count + 1`
     5883    if test $lt_ac_count -gt $lt_ac_max; then
     5884      lt_ac_max=$lt_ac_count
     5885      lt_cv_path_SED=$lt_ac_sed
     5886    fi
     5887  done
     5888done
     5889
     5890fi
     5891
     5892SED=$lt_cv_path_SED
     5893echo "$as_me:$LINENO: result: $SED" >&5
     5894echo "${ECHO_T}$SED" >&6
     5895
     5896
     5897# Check whether --with-gnu-ld or --without-gnu-ld was given.
     5898if test "${with_gnu_ld+set}" = set; then
     5899  withval="$with_gnu_ld"
     5900  test "$withval" = no || with_gnu_ld=yes
     5901else
     5902  with_gnu_ld=no
     5903fi;
     5904ac_prog=ld
     5905if test "$GCC" = yes; then
     5906  # Check if gcc -print-prog-name=ld gives a path.
     5907  echo "$as_me:$LINENO: checking for ld used by $CC" >&5
     5908echo $ECHO_N "checking for ld used by $CC... $ECHO_C" >&6
     5909  case $host in
     5910  *-*-mingw*)
     5911    # gcc leaves a trailing carriage return which upsets mingw
     5912    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
     5913  *)
     5914    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
     5915  esac
     5916  case $ac_prog in
     5917    # Accept absolute paths.
     5918    [\\/]* | ?:[\\/]*)
     5919      re_direlt='/[^/][^/]*/\.\./'
     5920      # Canonicalize the pathname of ld
     5921      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
     5922      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
     5923        ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
     5924      done
     5925      test -z "$LD" && LD="$ac_prog"
     5926      ;;
     5927  "")
     5928    # If it fails, then pretend we aren't using GCC.
     5929    ac_prog=ld
     5930    ;;
     5931  *)
     5932    # If it is relative, then search for the first ld in PATH.
     5933    with_gnu_ld=unknown
     5934    ;;
     5935  esac
     5936elif test "$with_gnu_ld" = yes; then
     5937  echo "$as_me:$LINENO: checking for GNU ld" >&5
     5938echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
     5939else
     5940  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
     5941echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
     5942fi
     5943if test "${lt_cv_path_LD+set}" = set; then
     5944  echo $ECHO_N "(cached) $ECHO_C" >&6
     5945else
     5946  if test -z "$LD"; then
     5947  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     5948  for ac_dir in $PATH; do
     5949    IFS="$lt_save_ifs"
     5950    test -z "$ac_dir" && ac_dir=.
     5951    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
     5952      lt_cv_path_LD="$ac_dir/$ac_prog"
     5953      # Check to see if the program is GNU ld.  I'd rather use --version,
     5954      # but apparently some variants of GNU ld only accept -v.
     5955      # Break only if it was the GNU/non-GNU ld that we prefer.
     5956      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
     5957      *GNU* | *'with BFD'*)
     5958        test "$with_gnu_ld" != no && break
     5959        ;;
     5960      *)
     5961        test "$with_gnu_ld" != yes && break
     5962        ;;
     5963      esac
     5964    fi
     5965  done
     5966  IFS="$lt_save_ifs"
     5967else
     5968  lt_cv_path_LD="$LD" # Let the user override the test with a path.
     5969fi
     5970fi
     5971
     5972LD="$lt_cv_path_LD"
     5973if test -n "$LD"; then
     5974  echo "$as_me:$LINENO: result: $LD" >&5
     5975echo "${ECHO_T}$LD" >&6
     5976else
     5977  echo "$as_me:$LINENO: result: no" >&5
     5978echo "${ECHO_T}no" >&6
     5979fi
     5980test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
     5981echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
     5982   { (exit 1); exit 1; }; }
     5983echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
     5984echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
     5985if test "${lt_cv_prog_gnu_ld+set}" = set; then
     5986  echo $ECHO_N "(cached) $ECHO_C" >&6
     5987else
     5988  # I'd rather use --version here, but apparently some GNU lds only accept -v.
     5989case `$LD -v 2>&1 </dev/null` in
     5990*GNU* | *'with BFD'*)
     5991  lt_cv_prog_gnu_ld=yes
     5992  ;;
     5993*)
     5994  lt_cv_prog_gnu_ld=no
     5995  ;;
     5996esac
     5997fi
     5998echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
     5999echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
     6000with_gnu_ld=$lt_cv_prog_gnu_ld
     6001
     6002
     6003echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
     6004echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
     6005if test "${lt_cv_ld_reload_flag+set}" = set; then
     6006  echo $ECHO_N "(cached) $ECHO_C" >&6
     6007else
     6008  lt_cv_ld_reload_flag='-r'
     6009fi
     6010echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
     6011echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
     6012reload_flag=$lt_cv_ld_reload_flag
     6013case $reload_flag in
     6014"" | " "*) ;;
     6015*) reload_flag=" $reload_flag" ;;
     6016esac
     6017reload_cmds='$LD$reload_flag -o $output$reload_objs'
     6018case $host_os in
     6019  darwin*)
     6020    if test "$GCC" = yes; then
     6021      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
     6022    else
     6023      reload_cmds='$LD$reload_flag -o $output$reload_objs'
     6024    fi
     6025    ;;
     6026esac
     6027
     6028echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
     6029echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
     6030if test "${lt_cv_path_NM+set}" = set; then
     6031  echo $ECHO_N "(cached) $ECHO_C" >&6
     6032else
     6033  if test -n "$NM"; then
     6034  # Let the user override the test.
     6035  lt_cv_path_NM="$NM"
     6036else
     6037  lt_nm_to_check="${ac_tool_prefix}nm"
     6038  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
     6039    lt_nm_to_check="$lt_nm_to_check nm"
     6040  fi
     6041  for lt_tmp_nm in $lt_nm_to_check; do
     6042    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     6043    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
     6044      IFS="$lt_save_ifs"
     6045      test -z "$ac_dir" && ac_dir=.
     6046      tmp_nm="$ac_dir/$lt_tmp_nm"
     6047      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
     6048        # Check to see if the nm accepts a BSD-compat flag.
     6049        # Adding the `sed 1q' prevents false positives on HP-UX, which says:
     6050        #   nm: unknown option "B" ignored
     6051        # Tru64's nm complains that /dev/null is an invalid object file
     6052        case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
     6053        */dev/null* | *'Invalid file or object type'*)
     6054          lt_cv_path_NM="$tmp_nm -B"
     6055          break
     6056          ;;
     6057        *)
     6058          case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
     6059          */dev/null*)
     6060            lt_cv_path_NM="$tmp_nm -p"
     6061            break
     6062            ;;
     6063          *)
     6064            lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
     6065            continue # so that we can try to find one that supports BSD flags
     6066            ;;
     6067          esac
     6068          ;;
     6069        esac
     6070      fi
     6071    done
     6072    IFS="$lt_save_ifs"
     6073  done
     6074  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
     6075fi
     6076fi
     6077echo "$as_me:$LINENO: result: $lt_cv_path_NM" >&5
     6078echo "${ECHO_T}$lt_cv_path_NM" >&6
     6079NM="$lt_cv_path_NM"
     6080
     6081echo "$as_me:$LINENO: checking whether ln -s works" >&5
     6082echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
     6083LN_S=$as_ln_s
     6084if test "$LN_S" = "ln -s"; then
     6085  echo "$as_me:$LINENO: result: yes" >&5
     6086echo "${ECHO_T}yes" >&6
     6087else
     6088  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
     6089echo "${ECHO_T}no, using $LN_S" >&6
     6090fi
     6091
     6092echo "$as_me:$LINENO: checking how to recognise dependent libraries" >&5
     6093echo $ECHO_N "checking how to recognise dependent libraries... $ECHO_C" >&6
     6094if test "${lt_cv_deplibs_check_method+set}" = set; then
     6095  echo $ECHO_N "(cached) $ECHO_C" >&6
     6096else
     6097  lt_cv_file_magic_cmd='$MAGIC_CMD'
     6098lt_cv_file_magic_test_file=
     6099lt_cv_deplibs_check_method='unknown'
     6100# Need to set the preceding variable on all platforms that support
     6101# interlibrary dependencies.
     6102# 'none' -- dependencies not supported.
     6103# `unknown' -- same as none, but documents that we really don't know.
     6104# 'pass_all' -- all dependencies passed with no checks.
     6105# 'test_compile' -- check by making test program.
     6106# 'file_magic [[regex]]' -- check by looking for files in library path
     6107# which responds to the $file_magic_cmd with a given extended regex.
     6108# If you have `file' or equivalent on your system and you're not sure
     6109# whether `pass_all' will *always* work, you probably want this one.
     6110
     6111case $host_os in
     6112aix4* | aix5*)
     6113  lt_cv_deplibs_check_method=pass_all
     6114  ;;
     6115
     6116beos*)
     6117  lt_cv_deplibs_check_method=pass_all
     6118  ;;
     6119
     6120bsdi[45]*)
     6121  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
     6122  lt_cv_file_magic_cmd='/usr/bin/file -L'
     6123  lt_cv_file_magic_test_file=/shlib/libc.so
     6124  ;;
     6125
     6126cygwin*)
     6127  # func_win32_libid is a shell function defined in ltmain.sh
     6128  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
     6129  lt_cv_file_magic_cmd='func_win32_libid'
     6130  ;;
     6131
     6132mingw* | pw32*)
     6133  # Base MSYS/MinGW do not provide the 'file' command needed by
     6134  # func_win32_libid shell function, so use a weaker test based on 'objdump'.
     6135  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
     6136  lt_cv_file_magic_cmd='$OBJDUMP -f'
     6137  ;;
     6138
     6139darwin* | rhapsody*)
     6140  lt_cv_deplibs_check_method=pass_all
     6141  ;;
     6142
     6143freebsd* | kfreebsd*-gnu | dragonfly*)
     6144  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
     6145    case $host_cpu in
     6146    i*86 )
     6147      # Not sure whether the presence of OpenBSD here was a mistake.
     6148      # Let's accept both of them until this is cleared up.
     6149      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
     6150      lt_cv_file_magic_cmd=/usr/bin/file
     6151      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
     6152      ;;
     6153    esac
     6154  else
     6155    lt_cv_deplibs_check_method=pass_all
     6156  fi
     6157  ;;
     6158
     6159gnu*)
     6160  lt_cv_deplibs_check_method=pass_all
     6161  ;;
     6162
     6163hpux10.20* | hpux11*)
     6164  lt_cv_file_magic_cmd=/usr/bin/file
     6165  case $host_cpu in
     6166  ia64*)
     6167    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
     6168    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
     6169    ;;
     6170  hppa*64*)
     6171    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]'
     6172    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
     6173    ;;
     6174  *)
     6175    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
     6176    lt_cv_file_magic_test_file=/usr/lib/libc.sl
     6177    ;;
     6178  esac
     6179  ;;
     6180
     6181interix3*)
     6182  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
     6183  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
     6184  ;;
     6185
     6186irix5* | irix6* | nonstopux*)
     6187  case $LD in
     6188  *-32|*"-32 ") libmagic=32-bit;;
     6189  *-n32|*"-n32 ") libmagic=N32;;
     6190  *-64|*"-64 ") libmagic=64-bit;;
     6191  *) libmagic=never-match;;
     6192  esac
     6193  lt_cv_deplibs_check_method=pass_all
     6194  ;;
     6195
     6196# This must be Linux ELF.
     6197linux*)
     6198  lt_cv_deplibs_check_method=pass_all
     6199  ;;
     6200
     6201netbsd*)
     6202  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
     6203    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
     6204  else
     6205    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
     6206  fi
     6207  ;;
     6208
     6209newos6*)
     6210  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
     6211  lt_cv_file_magic_cmd=/usr/bin/file
     6212  lt_cv_file_magic_test_file=/usr/lib/libnls.so
     6213  ;;
     6214
     6215nto-qnx*)
     6216  lt_cv_deplibs_check_method=unknown
     6217  ;;
     6218
     6219openbsd*)
     6220  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
     6221    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
     6222  else
     6223    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
     6224  fi
     6225  ;;
     6226
     6227osf3* | osf4* | osf5*)
     6228  lt_cv_deplibs_check_method=pass_all
     6229  ;;
     6230
     6231solaris*)
     6232  lt_cv_deplibs_check_method=pass_all
     6233  ;;
     6234
     6235sysv4 | sysv4.3*)
     6236  case $host_vendor in
     6237  motorola)
     6238    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
     6239    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
     6240    ;;
     6241  ncr)
     6242    lt_cv_deplibs_check_method=pass_all
     6243    ;;
     6244  sequent)
     6245    lt_cv_file_magic_cmd='/bin/file'
     6246    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
     6247    ;;
     6248  sni)
     6249    lt_cv_file_magic_cmd='/bin/file'
     6250    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
     6251    lt_cv_file_magic_test_file=/lib/libc.so
     6252    ;;
     6253  siemens)
     6254    lt_cv_deplibs_check_method=pass_all
     6255    ;;
     6256  pc)
     6257    lt_cv_deplibs_check_method=pass_all
     6258    ;;
     6259  esac
     6260  ;;
     6261
     6262sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
     6263  lt_cv_deplibs_check_method=pass_all
     6264  ;;
     6265esac
     6266
     6267fi
     6268echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
     6269echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
     6270file_magic_cmd=$lt_cv_file_magic_cmd
     6271deplibs_check_method=$lt_cv_deplibs_check_method
     6272test -z "$deplibs_check_method" && deplibs_check_method=unknown
     6273
     6274
     6275
     6276
     6277# If no C compiler was specified, use CC.
     6278LTCC=${LTCC-"$CC"}
     6279
     6280# If no C compiler flags were specified, use CFLAGS.
     6281LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
     6282
     6283# Allow CC to be a program name with arguments.
     6284compiler=$CC
     6285
     6286# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
     6287if test "${enable_libtool_lock+set}" = set; then
     6288  enableval="$enable_libtool_lock"
     6289
     6290fi;
     6291test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
     6292
     6293# Some flags need to be propagated to the compiler or linker for good
     6294# libtool support.
     6295case $host in
     6296ia64-*-hpux*)
     6297  # Find out which ABI we are using.
     6298  echo 'int i;' > conftest.$ac_ext
     6299  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6300  (eval $ac_compile) 2>&5
     6301  ac_status=$?
     6302  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6303  (exit $ac_status); }; then
     6304    case `/usr/bin/file conftest.$ac_objext` in
     6305    *ELF-32*)
     6306      HPUX_IA64_MODE="32"
     6307      ;;
     6308    *ELF-64*)
     6309      HPUX_IA64_MODE="64"
     6310      ;;
     6311    esac
     6312  fi
     6313  rm -rf conftest*
     6314  ;;
     6315*-*-irix6*)
     6316  # Find out which ABI we are using.
     6317  echo '#line 6317 "configure"' > conftest.$ac_ext
     6318  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6319  (eval $ac_compile) 2>&5
     6320  ac_status=$?
     6321  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6322  (exit $ac_status); }; then
     6323   if test "$lt_cv_prog_gnu_ld" = yes; then
     6324    case `/usr/bin/file conftest.$ac_objext` in
     6325    *32-bit*)
     6326      LD="${LD-ld} -melf32bsmip"
     6327      ;;
     6328    *N32*)
     6329      LD="${LD-ld} -melf32bmipn32"
     6330      ;;
     6331    *64-bit*)
     6332      LD="${LD-ld} -melf64bmip"
     6333      ;;
     6334    esac
     6335   else
     6336    case `/usr/bin/file conftest.$ac_objext` in
     6337    *32-bit*)
     6338      LD="${LD-ld} -32"
     6339      ;;
     6340    *N32*)
     6341      LD="${LD-ld} -n32"
     6342      ;;
     6343    *64-bit*)
     6344      LD="${LD-ld} -64"
     6345      ;;
     6346    esac
     6347   fi
     6348  fi
     6349  rm -rf conftest*
     6350  ;;
     6351
     6352x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
     6353  # Find out which ABI we are using.
     6354  echo 'int i;' > conftest.$ac_ext
     6355  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6356  (eval $ac_compile) 2>&5
     6357  ac_status=$?
     6358  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6359  (exit $ac_status); }; then
     6360    case `/usr/bin/file conftest.o` in
     6361    *32-bit*)
     6362      case $host in
     6363        x86_64-*linux*)
     6364          LD="${LD-ld} -m elf_i386"
     6365          ;;
     6366        ppc64-*linux*|powerpc64-*linux*)
     6367          LD="${LD-ld} -m elf32ppclinux"
     6368          ;;
     6369        s390x-*linux*)
     6370          LD="${LD-ld} -m elf_s390"
     6371          ;;
     6372        sparc64-*linux*)
     6373          LD="${LD-ld} -m elf32_sparc"
     6374          ;;
     6375      esac
     6376      ;;
     6377    *64-bit*)
     6378      case $host in
     6379        x86_64-*linux*)
     6380          LD="${LD-ld} -m elf_x86_64"
     6381          ;;
     6382        ppc*-*linux*|powerpc*-*linux*)
     6383          LD="${LD-ld} -m elf64ppc"
     6384          ;;
     6385        s390*-*linux*)
     6386          LD="${LD-ld} -m elf64_s390"
     6387          ;;
     6388        sparc*-*linux*)
     6389          LD="${LD-ld} -m elf64_sparc"
     6390          ;;
     6391      esac
     6392      ;;
     6393    esac
     6394  fi
     6395  rm -rf conftest*
     6396  ;;
     6397
     6398*-*-sco3.2v5*)
     6399  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
     6400  SAVE_CFLAGS="$CFLAGS"
     6401  CFLAGS="$CFLAGS -belf"
     6402  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
     6403echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
     6404if test "${lt_cv_cc_needs_belf+set}" = set; then
     6405  echo $ECHO_N "(cached) $ECHO_C" >&6
     6406else
     6407  ac_ext=c
     6408ac_cpp='$CPP $CPPFLAGS'
     6409ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     6410ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     6411ac_compiler_gnu=$ac_cv_c_compiler_gnu
     6412
     6413     cat >conftest.$ac_ext <<_ACEOF
     6414/* confdefs.h.  */
     6415_ACEOF
     6416cat confdefs.h >>conftest.$ac_ext
     6417cat >>conftest.$ac_ext <<_ACEOF
     6418/* end confdefs.h.  */
     6419
     6420int
     6421main ()
     6422{
     6423
     6424  ;
     6425  return 0;
     6426}
     6427_ACEOF
     6428rm -f conftest.$ac_objext conftest$ac_exeext
     6429if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     6430  (eval $ac_link) 2>conftest.er1
     6431  ac_status=$?
     6432  grep -v '^ *+' conftest.er1 >conftest.err
     6433  rm -f conftest.er1
     6434  cat conftest.err >&5
     6435  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6436  (exit $ac_status); } &&
     6437         { ac_try='test -z "$ac_c_werror_flag"
     6438                         || test ! -s conftest.err'
     6439  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6440  (eval $ac_try) 2>&5
     6441  ac_status=$?
     6442  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6443  (exit $ac_status); }; } &&
     6444         { ac_try='test -s conftest$ac_exeext'
     6445  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6446  (eval $ac_try) 2>&5
     6447  ac_status=$?
     6448  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6449  (exit $ac_status); }; }; then
     6450  lt_cv_cc_needs_belf=yes
     6451else
     6452  echo "$as_me: failed program was:" >&5
     6453sed 's/^/| /' conftest.$ac_ext >&5
     6454
     6455lt_cv_cc_needs_belf=no
     6456fi
     6457rm -f conftest.err conftest.$ac_objext \
     6458      conftest$ac_exeext conftest.$ac_ext
     6459     ac_ext=c
     6460ac_cpp='$CPP $CPPFLAGS'
     6461ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     6462ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     6463ac_compiler_gnu=$ac_cv_c_compiler_gnu
     6464
     6465fi
     6466echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
     6467echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
     6468  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
     6469    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
     6470    CFLAGS="$SAVE_CFLAGS"
     6471  fi
     6472  ;;
     6473sparc*-*solaris*)
     6474  # Find out which ABI we are using.
     6475  echo 'int i;' > conftest.$ac_ext
     6476  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6477  (eval $ac_compile) 2>&5
     6478  ac_status=$?
     6479  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6480  (exit $ac_status); }; then
     6481    case `/usr/bin/file conftest.o` in
     6482    *64-bit*)
     6483      case $lt_cv_prog_gnu_ld in
     6484      yes*) LD="${LD-ld} -m elf64_sparc" ;;
     6485      *)    LD="${LD-ld} -64" ;;
     6486      esac
     6487      ;;
     6488    esac
     6489  fi
     6490  rm -rf conftest*
     6491  ;;
     6492
     6493
     6494esac
     6495
     6496need_locks="$enable_libtool_lock"
     6497
     6498
     6499ac_ext=c
     6500ac_cpp='$CPP $CPPFLAGS'
     6501ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     6502ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     6503ac_compiler_gnu=$ac_cv_c_compiler_gnu
     6504echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
     6505echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
     6506# On Suns, sometimes $CPP names a directory.
     6507if test -n "$CPP" && test -d "$CPP"; then
     6508  CPP=
     6509fi
     6510if test -z "$CPP"; then
     6511  if test "${ac_cv_prog_CPP+set}" = set; then
     6512  echo $ECHO_N "(cached) $ECHO_C" >&6
     6513else
     6514      # Double quotes because CPP needs to be expanded
     6515    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
     6516    do
     6517      ac_preproc_ok=false
     6518for ac_c_preproc_warn_flag in '' yes
     6519do
     6520  # Use a header file that comes with gcc, so configuring glibc
     6521  # with a fresh cross-compiler works.
     6522  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     6523  # <limits.h> exists even on freestanding compilers.
     6524  # On the NeXT, cc -E runs the code through the compiler's parser,
     6525  # not just through cpp. "Syntax error" is here to catch this case.
     6526  cat >conftest.$ac_ext <<_ACEOF
     6527/* confdefs.h.  */
     6528_ACEOF
     6529cat confdefs.h >>conftest.$ac_ext
     6530cat >>conftest.$ac_ext <<_ACEOF
     6531/* end confdefs.h.  */
     6532#ifdef __STDC__
     6533# include <limits.h>
     6534#else
     6535# include <assert.h>
     6536#endif
     6537                     Syntax error
     6538_ACEOF
     6539if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     6540  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     6541  ac_status=$?
     6542  grep -v '^ *+' conftest.er1 >conftest.err
     6543  rm -f conftest.er1
     6544  cat conftest.err >&5
     6545  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6546  (exit $ac_status); } >/dev/null; then
     6547  if test -s conftest.err; then
     6548    ac_cpp_err=$ac_c_preproc_warn_flag
     6549    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
     6550  else
     6551    ac_cpp_err=
     6552  fi
     6553else
     6554  ac_cpp_err=yes
     6555fi
     6556if test -z "$ac_cpp_err"; then
     6557  :
     6558else
     6559  echo "$as_me: failed program was:" >&5
     6560sed 's/^/| /' conftest.$ac_ext >&5
     6561
     6562  # Broken: fails on valid input.
     6563continue
     6564fi
     6565rm -f conftest.err conftest.$ac_ext
     6566
     6567  # OK, works on sane cases.  Now check whether non-existent headers
     6568  # can be detected and how.
     6569  cat >conftest.$ac_ext <<_ACEOF
     6570/* confdefs.h.  */
     6571_ACEOF
     6572cat confdefs.h >>conftest.$ac_ext
     6573cat >>conftest.$ac_ext <<_ACEOF
     6574/* end confdefs.h.  */
     6575#include <ac_nonexistent.h>
     6576_ACEOF
     6577if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     6578  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     6579  ac_status=$?
     6580  grep -v '^ *+' conftest.er1 >conftest.err
     6581  rm -f conftest.er1
     6582  cat conftest.err >&5
     6583  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6584  (exit $ac_status); } >/dev/null; then
     6585  if test -s conftest.err; then
     6586    ac_cpp_err=$ac_c_preproc_warn_flag
     6587    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
     6588  else
     6589    ac_cpp_err=
     6590  fi
     6591else
     6592  ac_cpp_err=yes
     6593fi
     6594if test -z "$ac_cpp_err"; then
     6595  # Broken: success on invalid input.
     6596continue
     6597else
     6598  echo "$as_me: failed program was:" >&5
     6599sed 's/^/| /' conftest.$ac_ext >&5
     6600
     6601  # Passes both tests.
     6602ac_preproc_ok=:
     6603break
     6604fi
     6605rm -f conftest.err conftest.$ac_ext
     6606
     6607done
     6608# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     6609rm -f conftest.err conftest.$ac_ext
     6610if $ac_preproc_ok; then
     6611  break
     6612fi
     6613
     6614    done
     6615    ac_cv_prog_CPP=$CPP
     6616
     6617fi
     6618  CPP=$ac_cv_prog_CPP
     6619else
     6620  ac_cv_prog_CPP=$CPP
     6621fi
     6622echo "$as_me:$LINENO: result: $CPP" >&5
     6623echo "${ECHO_T}$CPP" >&6
     6624ac_preproc_ok=false
     6625for ac_c_preproc_warn_flag in '' yes
     6626do
     6627  # Use a header file that comes with gcc, so configuring glibc
     6628  # with a fresh cross-compiler works.
     6629  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     6630  # <limits.h> exists even on freestanding compilers.
     6631  # On the NeXT, cc -E runs the code through the compiler's parser,
     6632  # not just through cpp. "Syntax error" is here to catch this case.
     6633  cat >conftest.$ac_ext <<_ACEOF
     6634/* confdefs.h.  */
     6635_ACEOF
     6636cat confdefs.h >>conftest.$ac_ext
     6637cat >>conftest.$ac_ext <<_ACEOF
     6638/* end confdefs.h.  */
     6639#ifdef __STDC__
     6640# include <limits.h>
     6641#else
     6642# include <assert.h>
     6643#endif
     6644                     Syntax error
     6645_ACEOF
     6646if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     6647  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     6648  ac_status=$?
     6649  grep -v '^ *+' conftest.er1 >conftest.err
     6650  rm -f conftest.er1
     6651  cat conftest.err >&5
     6652  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6653  (exit $ac_status); } >/dev/null; then
     6654  if test -s conftest.err; then
     6655    ac_cpp_err=$ac_c_preproc_warn_flag
     6656    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
     6657  else
     6658    ac_cpp_err=
     6659  fi
     6660else
     6661  ac_cpp_err=yes
     6662fi
     6663if test -z "$ac_cpp_err"; then
     6664  :
     6665else
     6666  echo "$as_me: failed program was:" >&5
     6667sed 's/^/| /' conftest.$ac_ext >&5
     6668
     6669  # Broken: fails on valid input.
     6670continue
     6671fi
     6672rm -f conftest.err conftest.$ac_ext
     6673
     6674  # OK, works on sane cases.  Now check whether non-existent headers
     6675  # can be detected and how.
     6676  cat >conftest.$ac_ext <<_ACEOF
     6677/* confdefs.h.  */
     6678_ACEOF
     6679cat confdefs.h >>conftest.$ac_ext
     6680cat >>conftest.$ac_ext <<_ACEOF
     6681/* end confdefs.h.  */
     6682#include <ac_nonexistent.h>
     6683_ACEOF
     6684if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     6685  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     6686  ac_status=$?
     6687  grep -v '^ *+' conftest.er1 >conftest.err
     6688  rm -f conftest.er1
     6689  cat conftest.err >&5
     6690  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6691  (exit $ac_status); } >/dev/null; then
     6692  if test -s conftest.err; then
     6693    ac_cpp_err=$ac_c_preproc_warn_flag
     6694    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
     6695  else
     6696    ac_cpp_err=
     6697  fi
     6698else
     6699  ac_cpp_err=yes
     6700fi
     6701if test -z "$ac_cpp_err"; then
     6702  # Broken: success on invalid input.
     6703continue
     6704else
     6705  echo "$as_me: failed program was:" >&5
     6706sed 's/^/| /' conftest.$ac_ext >&5
     6707
     6708  # Passes both tests.
     6709ac_preproc_ok=:
     6710break
     6711fi
     6712rm -f conftest.err conftest.$ac_ext
     6713
     6714done
     6715# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     6716rm -f conftest.err conftest.$ac_ext
     6717if $ac_preproc_ok; then
     6718  :
     6719else
     6720  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
     6721See \`config.log' for more details." >&5
     6722echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
     6723See \`config.log' for more details." >&2;}
     6724   { (exit 1); exit 1; }; }
     6725fi
     6726
     6727ac_ext=c
     6728ac_cpp='$CPP $CPPFLAGS'
     6729ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     6730ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     6731ac_compiler_gnu=$ac_cv_c_compiler_gnu
     6732
     6733
     6734echo "$as_me:$LINENO: checking for ANSI C header files" >&5
     6735echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
     6736if test "${ac_cv_header_stdc+set}" = set; then
     6737  echo $ECHO_N "(cached) $ECHO_C" >&6
     6738else
     6739  cat >conftest.$ac_ext <<_ACEOF
     6740/* confdefs.h.  */
     6741_ACEOF
     6742cat confdefs.h >>conftest.$ac_ext
     6743cat >>conftest.$ac_ext <<_ACEOF
     6744/* end confdefs.h.  */
     6745#include <stdlib.h>
     6746#include <stdarg.h>
     6747#include <string.h>
     6748#include <float.h>
     6749
     6750int
     6751main ()
     6752{
     6753
     6754  ;
     6755  return 0;
     6756}
     6757_ACEOF
     6758rm -f conftest.$ac_objext
     6759if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6760  (eval $ac_compile) 2>conftest.er1
     6761  ac_status=$?
     6762  grep -v '^ *+' conftest.er1 >conftest.err
     6763  rm -f conftest.er1
     6764  cat conftest.err >&5
     6765  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6766  (exit $ac_status); } &&
     6767         { ac_try='test -z "$ac_c_werror_flag"
     6768                         || test ! -s conftest.err'
     6769  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6770  (eval $ac_try) 2>&5
     6771  ac_status=$?
     6772  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6773  (exit $ac_status); }; } &&
     6774         { ac_try='test -s conftest.$ac_objext'
     6775  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6776  (eval $ac_try) 2>&5
     6777  ac_status=$?
     6778  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6779  (exit $ac_status); }; }; then
     6780  ac_cv_header_stdc=yes
     6781else
     6782  echo "$as_me: failed program was:" >&5
     6783sed 's/^/| /' conftest.$ac_ext >&5
     6784
     6785ac_cv_header_stdc=no
     6786fi
     6787rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     6788
     6789if test $ac_cv_header_stdc = yes; then
     6790  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
     6791  cat >conftest.$ac_ext <<_ACEOF
     6792/* confdefs.h.  */
     6793_ACEOF
     6794cat confdefs.h >>conftest.$ac_ext
     6795cat >>conftest.$ac_ext <<_ACEOF
     6796/* end confdefs.h.  */
     6797#include <string.h>
     6798
     6799_ACEOF
     6800if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
     6801  $EGREP "memchr" >/dev/null 2>&1; then
     6802  :
     6803else
     6804  ac_cv_header_stdc=no
     6805fi
     6806rm -f conftest*
     6807
     6808fi
     6809
     6810if test $ac_cv_header_stdc = yes; then
     6811  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
     6812  cat >conftest.$ac_ext <<_ACEOF
     6813/* confdefs.h.  */
     6814_ACEOF
     6815cat confdefs.h >>conftest.$ac_ext
     6816cat >>conftest.$ac_ext <<_ACEOF
     6817/* end confdefs.h.  */
     6818#include <stdlib.h>
     6819
     6820_ACEOF
     6821if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
     6822  $EGREP "free" >/dev/null 2>&1; then
     6823  :
     6824else
     6825  ac_cv_header_stdc=no
     6826fi
     6827rm -f conftest*
     6828
     6829fi
     6830
     6831if test $ac_cv_header_stdc = yes; then
     6832  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
     6833  if test "$cross_compiling" = yes; then
     6834  :
     6835else
     6836  cat >conftest.$ac_ext <<_ACEOF
     6837/* confdefs.h.  */
     6838_ACEOF
     6839cat confdefs.h >>conftest.$ac_ext
     6840cat >>conftest.$ac_ext <<_ACEOF
     6841/* end confdefs.h.  */
     6842#include <ctype.h>
     6843#if ((' ' & 0x0FF) == 0x020)
     6844# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
     6845# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
     6846#else
     6847# define ISLOWER(c) \
     6848                   (('a' <= (c) && (c) <= 'i') \
     6849                     || ('j' <= (c) && (c) <= 'r') \
     6850                     || ('s' <= (c) && (c) <= 'z'))
     6851# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
     6852#endif
     6853
     6854#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
     6855int
     6856main ()
     6857{
     6858  int i;
     6859  for (i = 0; i < 256; i++)
     6860    if (XOR (islower (i), ISLOWER (i))
     6861        || toupper (i) != TOUPPER (i))
     6862      exit(2);
     6863  exit (0);
     6864}
     6865_ACEOF
     6866rm -f conftest$ac_exeext
     6867if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     6868  (eval $ac_link) 2>&5
     6869  ac_status=$?
     6870  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6871  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
     6872  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6873  (eval $ac_try) 2>&5
     6874  ac_status=$?
     6875  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6876  (exit $ac_status); }; }; then
     6877  :
     6878else
     6879  echo "$as_me: program exited with status $ac_status" >&5
     6880echo "$as_me: failed program was:" >&5
     6881sed 's/^/| /' conftest.$ac_ext >&5
     6882
     6883( exit $ac_status )
     6884ac_cv_header_stdc=no
     6885fi
     6886rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
     6887fi
     6888fi
     6889fi
     6890echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
     6891echo "${ECHO_T}$ac_cv_header_stdc" >&6
     6892if test $ac_cv_header_stdc = yes; then
     6893
     6894cat >>confdefs.h <<\_ACEOF
     6895#define STDC_HEADERS 1
     6896_ACEOF
     6897
     6898fi
     6899
     6900# On IRIX 5.3, sys/types and inttypes.h are conflicting.
     6901
     6902
     6903
     6904
     6905
     6906
     6907
     6908
     6909
     6910for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
     6911                  inttypes.h stdint.h unistd.h
     6912do
     6913as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
     6914echo "$as_me:$LINENO: checking for $ac_header" >&5
     6915echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
     6916if eval "test \"\${$as_ac_Header+set}\" = set"; then
     6917  echo $ECHO_N "(cached) $ECHO_C" >&6
     6918else
     6919  cat >conftest.$ac_ext <<_ACEOF
     6920/* confdefs.h.  */
     6921_ACEOF
     6922cat confdefs.h >>conftest.$ac_ext
     6923cat >>conftest.$ac_ext <<_ACEOF
     6924/* end confdefs.h.  */
     6925$ac_includes_default
     6926
     6927#include <$ac_header>
     6928_ACEOF
     6929rm -f conftest.$ac_objext
     6930if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6931  (eval $ac_compile) 2>conftest.er1
     6932  ac_status=$?
     6933  grep -v '^ *+' conftest.er1 >conftest.err
     6934  rm -f conftest.er1
     6935  cat conftest.err >&5
     6936  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6937  (exit $ac_status); } &&
     6938         { ac_try='test -z "$ac_c_werror_flag"
     6939                         || test ! -s conftest.err'
     6940  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6941  (eval $ac_try) 2>&5
     6942  ac_status=$?
     6943  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6944  (exit $ac_status); }; } &&
     6945         { ac_try='test -s conftest.$ac_objext'
     6946  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     6947  (eval $ac_try) 2>&5
     6948  ac_status=$?
     6949  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     6950  (exit $ac_status); }; }; then
     6951  eval "$as_ac_Header=yes"
     6952else
     6953  echo "$as_me: failed program was:" >&5
     6954sed 's/^/| /' conftest.$ac_ext >&5
     6955
     6956eval "$as_ac_Header=no"
     6957fi
     6958rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     6959fi
     6960echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
     6961echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
     6962if test `eval echo '${'$as_ac_Header'}'` = yes; then
     6963  cat >>confdefs.h <<_ACEOF
     6964#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
     6965_ACEOF
     6966
     6967fi
     6968
     6969done
     6970
     6971
     6972
     6973for ac_header in dlfcn.h
     6974do
     6975as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
     6976if eval "test \"\${$as_ac_Header+set}\" = set"; then
     6977  echo "$as_me:$LINENO: checking for $ac_header" >&5
     6978echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
     6979if eval "test \"\${$as_ac_Header+set}\" = set"; then
     6980  echo $ECHO_N "(cached) $ECHO_C" >&6
     6981fi
     6982echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
     6983echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
     6984else
     6985  # Is the header compilable?
     6986echo "$as_me:$LINENO: checking $ac_header usability" >&5
     6987echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
     6988cat >conftest.$ac_ext <<_ACEOF
     6989/* confdefs.h.  */
     6990_ACEOF
     6991cat confdefs.h >>conftest.$ac_ext
     6992cat >>conftest.$ac_ext <<_ACEOF
     6993/* end confdefs.h.  */
     6994$ac_includes_default
     6995#include <$ac_header>
     6996_ACEOF
     6997rm -f conftest.$ac_objext
     6998if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     6999  (eval $ac_compile) 2>conftest.er1
     7000  ac_status=$?
     7001  grep -v '^ *+' conftest.er1 >conftest.err
     7002  rm -f conftest.er1
     7003  cat conftest.err >&5
     7004  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7005  (exit $ac_status); } &&
     7006         { ac_try='test -z "$ac_c_werror_flag"
     7007                         || test ! -s conftest.err'
     7008  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     7009  (eval $ac_try) 2>&5
     7010  ac_status=$?
     7011  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7012  (exit $ac_status); }; } &&
     7013         { ac_try='test -s conftest.$ac_objext'
     7014  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     7015  (eval $ac_try) 2>&5
     7016  ac_status=$?
     7017  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7018  (exit $ac_status); }; }; then
     7019  ac_header_compiler=yes
     7020else
     7021  echo "$as_me: failed program was:" >&5
     7022sed 's/^/| /' conftest.$ac_ext >&5
     7023
     7024ac_header_compiler=no
     7025fi
     7026rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     7027echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
     7028echo "${ECHO_T}$ac_header_compiler" >&6
     7029
     7030# Is the header present?
     7031echo "$as_me:$LINENO: checking $ac_header presence" >&5
     7032echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
     7033cat >conftest.$ac_ext <<_ACEOF
     7034/* confdefs.h.  */
     7035_ACEOF
     7036cat confdefs.h >>conftest.$ac_ext
     7037cat >>conftest.$ac_ext <<_ACEOF
     7038/* end confdefs.h.  */
     7039#include <$ac_header>
     7040_ACEOF
     7041if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     7042  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     7043  ac_status=$?
     7044  grep -v '^ *+' conftest.er1 >conftest.err
     7045  rm -f conftest.er1
     7046  cat conftest.err >&5
     7047  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7048  (exit $ac_status); } >/dev/null; then
     7049  if test -s conftest.err; then
     7050    ac_cpp_err=$ac_c_preproc_warn_flag
     7051    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
     7052  else
     7053    ac_cpp_err=
     7054  fi
     7055else
     7056  ac_cpp_err=yes
     7057fi
     7058if test -z "$ac_cpp_err"; then
     7059  ac_header_preproc=yes
     7060else
     7061  echo "$as_me: failed program was:" >&5
     7062sed 's/^/| /' conftest.$ac_ext >&5
     7063
     7064  ac_header_preproc=no
     7065fi
     7066rm -f conftest.err conftest.$ac_ext
     7067echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
     7068echo "${ECHO_T}$ac_header_preproc" >&6
     7069
     7070# So?  What about this header?
     7071case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
     7072  yes:no: )
     7073    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
     7074echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
     7075    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
     7076echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
     7077    ac_header_preproc=yes
     7078    ;;
     7079  no:yes:* )
     7080    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
     7081echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
     7082    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
     7083echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
     7084    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
     7085echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
     7086    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
     7087echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
     7088    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
     7089echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
     7090    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
     7091echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
     7092    (
     7093      cat <<\_ASBOX
     7094## ----------------------------------------- ##
     7095## Report this to coin-clp@lists.coin-or.org ##
     7096## ----------------------------------------- ##
     7097_ASBOX
     7098    ) |
     7099      sed "s/^/$as_me: WARNING:     /" >&2
     7100    ;;
     7101esac
     7102echo "$as_me:$LINENO: checking for $ac_header" >&5
     7103echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
     7104if eval "test \"\${$as_ac_Header+set}\" = set"; then
     7105  echo $ECHO_N "(cached) $ECHO_C" >&6
     7106else
     7107  eval "$as_ac_Header=\$ac_header_preproc"
     7108fi
     7109echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
     7110echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
     7111
     7112fi
     7113if test `eval echo '${'$as_ac_Header'}'` = yes; then
     7114  cat >>confdefs.h <<_ACEOF
     7115#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
     7116_ACEOF
     7117
     7118fi
     7119
     7120done
     7121
     7122
     7123
     7124if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
     7125    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
     7126    (test "X$CXX" != "Xg++"))) ; then
     7127  ac_ext=cc
     7128ac_cpp='$CXXCPP $CPPFLAGS'
     7129ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     7130ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     7131ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     7132echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
     7133echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
     7134if test -z "$CXXCPP"; then
     7135  if test "${ac_cv_prog_CXXCPP+set}" = set; then
     7136  echo $ECHO_N "(cached) $ECHO_C" >&6
     7137else
     7138      # Double quotes because CXXCPP needs to be expanded
     7139    for CXXCPP in "$CXX -E" "/lib/cpp"
     7140    do
     7141      ac_preproc_ok=false
     7142for ac_cxx_preproc_warn_flag in '' yes
     7143do
     7144  # Use a header file that comes with gcc, so configuring glibc
     7145  # with a fresh cross-compiler works.
     7146  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     7147  # <limits.h> exists even on freestanding compilers.
     7148  # On the NeXT, cc -E runs the code through the compiler's parser,
     7149  # not just through cpp. "Syntax error" is here to catch this case.
     7150  cat >conftest.$ac_ext <<_ACEOF
     7151/* confdefs.h.  */
     7152_ACEOF
     7153cat confdefs.h >>conftest.$ac_ext
     7154cat >>conftest.$ac_ext <<_ACEOF
     7155/* end confdefs.h.  */
     7156#ifdef __STDC__
     7157# include <limits.h>
     7158#else
     7159# include <assert.h>
     7160#endif
     7161                     Syntax error
     7162_ACEOF
     7163if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     7164  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     7165  ac_status=$?
     7166  grep -v '^ *+' conftest.er1 >conftest.err
     7167  rm -f conftest.er1
     7168  cat conftest.err >&5
     7169  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7170  (exit $ac_status); } >/dev/null; then
     7171  if test -s conftest.err; then
     7172    ac_cpp_err=$ac_cxx_preproc_warn_flag
     7173    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
     7174  else
     7175    ac_cpp_err=
     7176  fi
     7177else
     7178  ac_cpp_err=yes
     7179fi
     7180if test -z "$ac_cpp_err"; then
     7181  :
     7182else
     7183  echo "$as_me: failed program was:" >&5
     7184sed 's/^/| /' conftest.$ac_ext >&5
     7185
     7186  # Broken: fails on valid input.
     7187continue
     7188fi
     7189rm -f conftest.err conftest.$ac_ext
     7190
     7191  # OK, works on sane cases.  Now check whether non-existent headers
     7192  # can be detected and how.
     7193  cat >conftest.$ac_ext <<_ACEOF
     7194/* confdefs.h.  */
     7195_ACEOF
     7196cat confdefs.h >>conftest.$ac_ext
     7197cat >>conftest.$ac_ext <<_ACEOF
     7198/* end confdefs.h.  */
     7199#include <ac_nonexistent.h>
     7200_ACEOF
     7201if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     7202  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     7203  ac_status=$?
     7204  grep -v '^ *+' conftest.er1 >conftest.err
     7205  rm -f conftest.er1
     7206  cat conftest.err >&5
     7207  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7208  (exit $ac_status); } >/dev/null; then
     7209  if test -s conftest.err; then
     7210    ac_cpp_err=$ac_cxx_preproc_warn_flag
     7211    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
     7212  else
     7213    ac_cpp_err=
     7214  fi
     7215else
     7216  ac_cpp_err=yes
     7217fi
     7218if test -z "$ac_cpp_err"; then
     7219  # Broken: success on invalid input.
     7220continue
     7221else
     7222  echo "$as_me: failed program was:" >&5
     7223sed 's/^/| /' conftest.$ac_ext >&5
     7224
     7225  # Passes both tests.
     7226ac_preproc_ok=:
     7227break
     7228fi
     7229rm -f conftest.err conftest.$ac_ext
     7230
     7231done
     7232# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     7233rm -f conftest.err conftest.$ac_ext
     7234if $ac_preproc_ok; then
     7235  break
     7236fi
     7237
     7238    done
     7239    ac_cv_prog_CXXCPP=$CXXCPP
     7240
     7241fi
     7242  CXXCPP=$ac_cv_prog_CXXCPP
     7243else
     7244  ac_cv_prog_CXXCPP=$CXXCPP
     7245fi
     7246echo "$as_me:$LINENO: result: $CXXCPP" >&5
     7247echo "${ECHO_T}$CXXCPP" >&6
     7248ac_preproc_ok=false
     7249for ac_cxx_preproc_warn_flag in '' yes
     7250do
     7251  # Use a header file that comes with gcc, so configuring glibc
     7252  # with a fresh cross-compiler works.
     7253  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     7254  # <limits.h> exists even on freestanding compilers.
     7255  # On the NeXT, cc -E runs the code through the compiler's parser,
     7256  # not just through cpp. "Syntax error" is here to catch this case.
     7257  cat >conftest.$ac_ext <<_ACEOF
     7258/* confdefs.h.  */
     7259_ACEOF
     7260cat confdefs.h >>conftest.$ac_ext
     7261cat >>conftest.$ac_ext <<_ACEOF
     7262/* end confdefs.h.  */
     7263#ifdef __STDC__
     7264# include <limits.h>
     7265#else
     7266# include <assert.h>
     7267#endif
     7268                     Syntax error
     7269_ACEOF
     7270if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     7271  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     7272  ac_status=$?
     7273  grep -v '^ *+' conftest.er1 >conftest.err
     7274  rm -f conftest.er1
     7275  cat conftest.err >&5
     7276  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7277  (exit $ac_status); } >/dev/null; then
     7278  if test -s conftest.err; then
     7279    ac_cpp_err=$ac_cxx_preproc_warn_flag
     7280    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
     7281  else
     7282    ac_cpp_err=
     7283  fi
     7284else
     7285  ac_cpp_err=yes
     7286fi
     7287if test -z "$ac_cpp_err"; then
     7288  :
     7289else
     7290  echo "$as_me: failed program was:" >&5
     7291sed 's/^/| /' conftest.$ac_ext >&5
     7292
     7293  # Broken: fails on valid input.
     7294continue
     7295fi
     7296rm -f conftest.err conftest.$ac_ext
     7297
     7298  # OK, works on sane cases.  Now check whether non-existent headers
     7299  # can be detected and how.
     7300  cat >conftest.$ac_ext <<_ACEOF
     7301/* confdefs.h.  */
     7302_ACEOF
     7303cat confdefs.h >>conftest.$ac_ext
     7304cat >>conftest.$ac_ext <<_ACEOF
     7305/* end confdefs.h.  */
     7306#include <ac_nonexistent.h>
     7307_ACEOF
     7308if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
     7309  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
     7310  ac_status=$?
     7311  grep -v '^ *+' conftest.er1 >conftest.err
     7312  rm -f conftest.er1
     7313  cat conftest.err >&5
     7314  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7315  (exit $ac_status); } >/dev/null; then
     7316  if test -s conftest.err; then
     7317    ac_cpp_err=$ac_cxx_preproc_warn_flag
     7318    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
     7319  else
     7320    ac_cpp_err=
     7321  fi
     7322else
     7323  ac_cpp_err=yes
     7324fi
     7325if test -z "$ac_cpp_err"; then
     7326  # Broken: success on invalid input.
     7327continue
     7328else
     7329  echo "$as_me: failed program was:" >&5
     7330sed 's/^/| /' conftest.$ac_ext >&5
     7331
     7332  # Passes both tests.
     7333ac_preproc_ok=:
     7334break
     7335fi
     7336rm -f conftest.err conftest.$ac_ext
     7337
     7338done
     7339# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     7340rm -f conftest.err conftest.$ac_ext
     7341if $ac_preproc_ok; then
     7342  :
     7343else
     7344  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
     7345See \`config.log' for more details." >&5
     7346echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
     7347See \`config.log' for more details." >&2;}
     7348   { (exit 1); exit 1; }; }
     7349fi
     7350
     7351ac_ext=cc
     7352ac_cpp='$CXXCPP $CPPFLAGS'
     7353ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     7354ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     7355ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     7356
     7357fi
     7358
     7359
     7360# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
     7361
     7362# find the maximum length of command line arguments
     7363echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
     7364echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
     7365if test "${lt_cv_sys_max_cmd_len+set}" = set; then
     7366  echo $ECHO_N "(cached) $ECHO_C" >&6
     7367else
     7368    i=0
     7369  teststring="ABCD"
     7370
     7371  case $build_os in
     7372  msdosdjgpp*)
     7373    # On DJGPP, this test can blow up pretty badly due to problems in libc
     7374    # (any single argument exceeding 2000 bytes causes a buffer overrun
     7375    # during glob expansion).  Even if it were fixed, the result of this
     7376    # check would be larger than it should be.
     7377    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
     7378    ;;
     7379
     7380  gnu*)
     7381    # Under GNU Hurd, this test is not required because there is
     7382    # no limit to the length of command line arguments.
     7383    # Libtool will interpret -1 as no limit whatsoever
     7384    lt_cv_sys_max_cmd_len=-1;
     7385    ;;
     7386
     7387  cygwin* | mingw*)
     7388    # On Win9x/ME, this test blows up -- it succeeds, but takes
     7389    # about 5 minutes as the teststring grows exponentially.
     7390    # Worse, since 9x/ME are not pre-emptively multitasking,
     7391    # you end up with a "frozen" computer, even though with patience
     7392    # the test eventually succeeds (with a max line length of 256k).
     7393    # Instead, let's just punt: use the minimum linelength reported by
     7394    # all of the supported platforms: 8192 (on NT/2K/XP).
     7395    lt_cv_sys_max_cmd_len=8192;
     7396    ;;
     7397
     7398  amigaos*)
     7399    # On AmigaOS with pdksh, this test takes hours, literally.
     7400    # So we just punt and use a minimum line length of 8192.
     7401    lt_cv_sys_max_cmd_len=8192;
     7402    ;;
     7403
     7404  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
     7405    # This has been around since 386BSD, at least.  Likely further.
     7406    if test -x /sbin/sysctl; then
     7407      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
     7408    elif test -x /usr/sbin/sysctl; then
     7409      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
     7410    else
     7411      lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
     7412    fi
     7413    # And add a safety zone
     7414    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
     7415    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
     7416    ;;
     7417
     7418  interix*)
     7419    # We know the value 262144 and hardcode it with a safety zone (like BSD)
     7420    lt_cv_sys_max_cmd_len=196608
     7421    ;;
     7422
     7423  osf*)
     7424    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
     7425    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
     7426    # nice to cause kernel panics so lets avoid the loop below.
     7427    # First set a reasonable default.
     7428    lt_cv_sys_max_cmd_len=16384
     7429    #
     7430    if test -x /sbin/sysconfig; then
     7431      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
     7432        *1*) lt_cv_sys_max_cmd_len=-1 ;;
     7433      esac
     7434    fi
     7435    ;;
     7436  sco3.2v5*)
     7437    lt_cv_sys_max_cmd_len=102400
     7438    ;;
     7439  sysv5* | sco5v6* | sysv4.2uw2*)
     7440    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
     7441    if test -n "$kargmax"; then
     7442      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[         ]//'`
     7443    else
     7444      lt_cv_sys_max_cmd_len=32768
     7445    fi
     7446    ;;
     7447  *)
     7448    # If test is not a shell built-in, we'll probably end up computing a
     7449    # maximum length that is only half of the actual maximum length, but
     7450    # we can't tell.
     7451    SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
     7452    while (test "X"`$SHELL $0 --fallback-echo "X$teststring" 2>/dev/null` \
     7453               = "XX$teststring") >/dev/null 2>&1 &&
     7454            new_result=`expr "X$teststring" : ".*" 2>&1` &&
     7455            lt_cv_sys_max_cmd_len=$new_result &&
     7456            test $i != 17 # 1/2 MB should be enough
     7457    do
     7458      i=`expr $i + 1`
     7459      teststring=$teststring$teststring
     7460    done
     7461    teststring=
     7462    # Add a significant safety factor because C++ compilers can tack on massive
     7463    # amounts of additional arguments before passing them to the linker.
     7464    # It appears as though 1/2 is a usable value.
     7465    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
     7466    ;;
     7467  esac
     7468
     7469fi
     7470
     7471if test -n $lt_cv_sys_max_cmd_len ; then
     7472  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
     7473echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
     7474else
     7475  echo "$as_me:$LINENO: result: none" >&5
     7476echo "${ECHO_T}none" >&6
     7477fi
     7478
     7479
     7480
     7481
     7482# Check for command to grab the raw symbol name followed by C symbol from nm.
     7483echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5
     7484echo $ECHO_N "checking command to parse $NM output from $compiler object... $ECHO_C" >&6
     7485if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
     7486  echo $ECHO_N "(cached) $ECHO_C" >&6
     7487else
     7488
     7489# These are sane defaults that work on at least a few old systems.
     7490# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
     7491
     7492# Character class describing NM global symbol codes.
     7493symcode='[BCDEGRST]'
     7494
     7495# Regexp to match symbols that can be accessed directly from C.
     7496sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
     7497
     7498# Transform an extracted symbol line into a proper C declaration
     7499lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
     7500
     7501# Transform an extracted symbol line into symbol name and symbol address
     7502lt_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'"
     7503
     7504# Define system-specific variables.
     7505case $host_os in
     7506aix*)
     7507  symcode='[BCDT]'
     7508  ;;
     7509cygwin* | mingw* | pw32*)
     7510  symcode='[ABCDGISTW]'
     7511  ;;
     7512hpux*) # Its linker distinguishes data from code symbols
     7513  if test "$host_cpu" = ia64; then
     7514    symcode='[ABCDEGRST]'
     7515  fi
     7516  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
     7517  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'"
     7518  ;;
     7519linux*)
     7520  if test "$host_cpu" = ia64; then
     7521    symcode='[ABCDGIRSTW]'
     7522    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
     7523    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'"
     7524  fi
     7525  ;;
     7526irix* | nonstopux*)
     7527  symcode='[BCDEGRST]'
     7528  ;;
     7529osf*)
     7530  symcode='[BCDEGQRST]'
     7531  ;;
     7532solaris*)
     7533  symcode='[BDRT]'
     7534  ;;
     7535sco3.2v5*)
     7536  symcode='[DT]'
     7537  ;;
     7538sysv4.2uw2*)
     7539  symcode='[DT]'
     7540  ;;
     7541sysv5* | sco5v6* | unixware* | OpenUNIX*)
     7542  symcode='[ABDT]'
     7543  ;;
     7544sysv4)
     7545  symcode='[DFNSTU]'
     7546  ;;
     7547esac
     7548
     7549# Handle CRLF in mingw tool chain
     7550opt_cr=
     7551case $build_os in
     7552mingw*)
     7553  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
     7554  ;;
     7555esac
     7556
     7557# If we're using GNU nm, then use its standard symbol codes.
     7558case `$NM -V 2>&1` in
     7559*GNU* | *'with BFD'*)
     7560  symcode='[ABCDGIRSTW]' ;;
     7561esac
     7562
     7563# Try without a prefix undercore, then with it.
     7564for ac_symprfx in "" "_"; do
     7565
     7566  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
     7567  symxfrm="\\1 $ac_symprfx\\2 \\2"
     7568
     7569  # Write the raw and C identifiers.
     7570  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[       ]\($symcode$symcode*\)[         ][      ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
     7571
     7572  # Check to see that the pipe works correctly.
     7573  pipe_works=no
     7574
     7575  rm -f conftest*
     7576  cat > conftest.$ac_ext <<EOF
     7577#ifdef __cplusplus
     7578extern "C" {
     7579#endif
     7580char nm_test_var;
     7581void nm_test_func(){}
     7582#ifdef __cplusplus
     7583}
     7584#endif
     7585int main(){nm_test_var='a';nm_test_func();return(0);}
     7586EOF
     7587
     7588  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     7589  (eval $ac_compile) 2>&5
     7590  ac_status=$?
     7591  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7592  (exit $ac_status); }; then
     7593    # Now try to grab the symbols.
     7594    nlist=conftest.nm
     7595    if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
     7596  (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
     7597  ac_status=$?
     7598  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7599  (exit $ac_status); } && test -s "$nlist"; then
     7600      # Try sorting and uniquifying the output.
     7601      if sort "$nlist" | uniq > "$nlist"T; then
     7602        mv -f "$nlist"T "$nlist"
     7603      else
     7604        rm -f "$nlist"T
     7605      fi
     7606
     7607      # Make sure that we snagged all the symbols we need.
     7608      if grep ' nm_test_var$' "$nlist" >/dev/null; then
     7609        if grep ' nm_test_func$' "$nlist" >/dev/null; then
     7610          cat <<EOF > conftest.$ac_ext
     7611#ifdef __cplusplus
     7612extern "C" {
     7613#endif
     7614
     7615EOF
     7616          # Now generate the symbol file.
     7617          eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext'
     7618
     7619          cat <<EOF >> conftest.$ac_ext
     7620#if defined (__STDC__) && __STDC__
     7621# define lt_ptr_t void *
     7622#else
     7623# define lt_ptr_t char *
     7624# define const
     7625#endif
     7626
     7627/* The mapping between symbol names and symbols. */
     7628const struct {
     7629  const char *name;
     7630  lt_ptr_t address;
     7631}
     7632lt_preloaded_symbols[] =
     7633{
     7634EOF
     7635          $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext
     7636          cat <<\EOF >> conftest.$ac_ext
     7637  {0, (lt_ptr_t) 0}
     7638};
     7639
     7640#ifdef __cplusplus
     7641}
     7642#endif
     7643EOF
     7644          # Now try linking the two files.
     7645          mv conftest.$ac_objext conftstm.$ac_objext
     7646          lt_save_LIBS="$LIBS"
     7647          lt_save_CFLAGS="$CFLAGS"
     7648          LIBS="conftstm.$ac_objext"
     7649          CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
     7650          if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     7651  (eval $ac_link) 2>&5
     7652  ac_status=$?
     7653  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7654  (exit $ac_status); } && test -s conftest${ac_exeext}; then
     7655            pipe_works=yes
     7656          fi
     7657          LIBS="$lt_save_LIBS"
     7658          CFLAGS="$lt_save_CFLAGS"
     7659        else
     7660          echo "cannot find nm_test_func in $nlist" >&5
     7661        fi
     7662      else
     7663        echo "cannot find nm_test_var in $nlist" >&5
     7664      fi
     7665    else
     7666      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
     7667    fi
     7668  else
     7669    echo "$progname: failed program was:" >&5
     7670    cat conftest.$ac_ext >&5
     7671  fi
     7672  rm -f conftest* conftst*
     7673
     7674  # Do not use the global_symbol_pipe unless it works.
     7675  if test "$pipe_works" = yes; then
     7676    break
     7677  else
     7678    lt_cv_sys_global_symbol_pipe=
     7679  fi
     7680done
     7681
     7682fi
     7683
     7684if test -z "$lt_cv_sys_global_symbol_pipe"; then
     7685  lt_cv_sys_global_symbol_to_cdecl=
     7686fi
     7687if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
     7688  echo "$as_me:$LINENO: result: failed" >&5
     7689echo "${ECHO_T}failed" >&6
     7690else
     7691  echo "$as_me:$LINENO: result: ok" >&5
     7692echo "${ECHO_T}ok" >&6
     7693fi
     7694
     7695echo "$as_me:$LINENO: checking for objdir" >&5
     7696echo $ECHO_N "checking for objdir... $ECHO_C" >&6
     7697if test "${lt_cv_objdir+set}" = set; then
     7698  echo $ECHO_N "(cached) $ECHO_C" >&6
     7699else
     7700  rm -f .libs 2>/dev/null
     7701mkdir .libs 2>/dev/null
     7702if test -d .libs; then
     7703  lt_cv_objdir=.libs
     7704else
     7705  # MS-DOS does not allow filenames that begin with a dot.
     7706  lt_cv_objdir=_libs
     7707fi
     7708rmdir .libs 2>/dev/null
     7709fi
     7710echo "$as_me:$LINENO: result: $lt_cv_objdir" >&5
     7711echo "${ECHO_T}$lt_cv_objdir" >&6
     7712objdir=$lt_cv_objdir
     7713
     7714
     7715
     7716
     7717
     7718case $host_os in
     7719aix3*)
     7720  # AIX sometimes has problems with the GCC collect2 program.  For some
     7721  # reason, if we set the COLLECT_NAMES environment variable, the problems
     7722  # vanish in a puff of smoke.
     7723  if test "X${COLLECT_NAMES+set}" != Xset; then
     7724    COLLECT_NAMES=
     7725    export COLLECT_NAMES
     7726  fi
     7727  ;;
     7728esac
     7729
     7730# Sed substitution that helps us do robust quoting.  It backslashifies
     7731# metacharacters that are still active within double-quoted strings.
     7732Xsed='sed -e 1s/^X//'
     7733sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g'
     7734
     7735# Same as above, but do not quote variable references.
     7736double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g'
     7737
     7738# Sed substitution to delay expansion of an escaped shell variable in a
     7739# double_quote_subst'ed string.
     7740delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
     7741
     7742# Sed substitution to avoid accidental globbing in evaled expressions
     7743no_glob_subst='s/\*/\\\*/g'
     7744
     7745# Constants:
     7746rm="rm -f"
     7747
     7748# Global variables:
     7749default_ofile=libtool
     7750can_build_shared=yes
     7751
     7752# All known linkers require a `.a' archive for static linking (except MSVC,
     7753# which needs '.lib').
     7754libext=a
     7755ltmain="$ac_aux_dir/ltmain.sh"
     7756ofile="$default_ofile"
     7757with_gnu_ld="$lt_cv_prog_gnu_ld"
     7758
     7759if test -n "$ac_tool_prefix"; then
     7760  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
     7761set dummy ${ac_tool_prefix}ar; ac_word=$2
     7762echo "$as_me:$LINENO: checking for $ac_word" >&5
     7763echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     7764if test "${ac_cv_prog_AR+set}" = set; then
     7765  echo $ECHO_N "(cached) $ECHO_C" >&6
     7766else
     7767  if test -n "$AR"; then
     7768  ac_cv_prog_AR="$AR" # Let the user override the test.
     7769else
     7770as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7771for as_dir in $PATH
     7772do
     7773  IFS=$as_save_IFS
     7774  test -z "$as_dir" && as_dir=.
     7775  for ac_exec_ext in '' $ac_executable_extensions; do
     7776  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     7777    ac_cv_prog_AR="${ac_tool_prefix}ar"
     7778    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7779    break 2
     7780  fi
     7781done
     7782done
     7783
     7784fi
     7785fi
     7786AR=$ac_cv_prog_AR
     7787if test -n "$AR"; then
     7788  echo "$as_me:$LINENO: result: $AR" >&5
     7789echo "${ECHO_T}$AR" >&6
     7790else
     7791  echo "$as_me:$LINENO: result: no" >&5
     7792echo "${ECHO_T}no" >&6
     7793fi
     7794
     7795fi
     7796if test -z "$ac_cv_prog_AR"; then
     7797  ac_ct_AR=$AR
     7798  # Extract the first word of "ar", so it can be a program name with args.
     7799set dummy ar; ac_word=$2
     7800echo "$as_me:$LINENO: checking for $ac_word" >&5
     7801echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     7802if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
     7803  echo $ECHO_N "(cached) $ECHO_C" >&6
     7804else
     7805  if test -n "$ac_ct_AR"; then
     7806  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
     7807else
     7808as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7809for as_dir in $PATH
     7810do
     7811  IFS=$as_save_IFS
     7812  test -z "$as_dir" && as_dir=.
     7813  for ac_exec_ext in '' $ac_executable_extensions; do
     7814  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     7815    ac_cv_prog_ac_ct_AR="ar"
     7816    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7817    break 2
     7818  fi
     7819done
     7820done
     7821
     7822  test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="false"
     7823fi
     7824fi
     7825ac_ct_AR=$ac_cv_prog_ac_ct_AR
     7826if test -n "$ac_ct_AR"; then
     7827  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
     7828echo "${ECHO_T}$ac_ct_AR" >&6
     7829else
     7830  echo "$as_me:$LINENO: result: no" >&5
     7831echo "${ECHO_T}no" >&6
     7832fi
     7833
     7834  AR=$ac_ct_AR
     7835else
     7836  AR="$ac_cv_prog_AR"
     7837fi
     7838
     7839if test -n "$ac_tool_prefix"; then
     7840  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
     7841set dummy ${ac_tool_prefix}ranlib; ac_word=$2
     7842echo "$as_me:$LINENO: checking for $ac_word" >&5
     7843echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     7844if test "${ac_cv_prog_RANLIB+set}" = set; then
     7845  echo $ECHO_N "(cached) $ECHO_C" >&6
     7846else
     7847  if test -n "$RANLIB"; then
     7848  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
     7849else
     7850as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7851for as_dir in $PATH
     7852do
     7853  IFS=$as_save_IFS
     7854  test -z "$as_dir" && as_dir=.
     7855  for ac_exec_ext in '' $ac_executable_extensions; do
     7856  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     7857    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
     7858    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7859    break 2
     7860  fi
     7861done
     7862done
     7863
     7864fi
     7865fi
     7866RANLIB=$ac_cv_prog_RANLIB
     7867if test -n "$RANLIB"; then
     7868  echo "$as_me:$LINENO: result: $RANLIB" >&5
     7869echo "${ECHO_T}$RANLIB" >&6
     7870else
     7871  echo "$as_me:$LINENO: result: no" >&5
     7872echo "${ECHO_T}no" >&6
     7873fi
     7874
     7875fi
     7876if test -z "$ac_cv_prog_RANLIB"; then
     7877  ac_ct_RANLIB=$RANLIB
     7878  # Extract the first word of "ranlib", so it can be a program name with args.
     7879set dummy ranlib; ac_word=$2
     7880echo "$as_me:$LINENO: checking for $ac_word" >&5
     7881echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     7882if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
     7883  echo $ECHO_N "(cached) $ECHO_C" >&6
     7884else
     7885  if test -n "$ac_ct_RANLIB"; then
     7886  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
     7887else
     7888as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7889for as_dir in $PATH
     7890do
     7891  IFS=$as_save_IFS
     7892  test -z "$as_dir" && as_dir=.
     7893  for ac_exec_ext in '' $ac_executable_extensions; do
     7894  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     7895    ac_cv_prog_ac_ct_RANLIB="ranlib"
     7896    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7897    break 2
     7898  fi
     7899done
     7900done
     7901
     7902  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
     7903fi
     7904fi
     7905ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
     7906if test -n "$ac_ct_RANLIB"; then
     7907  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
     7908echo "${ECHO_T}$ac_ct_RANLIB" >&6
     7909else
     7910  echo "$as_me:$LINENO: result: no" >&5
     7911echo "${ECHO_T}no" >&6
     7912fi
     7913
     7914  RANLIB=$ac_ct_RANLIB
     7915else
     7916  RANLIB="$ac_cv_prog_RANLIB"
     7917fi
     7918
     7919if test -n "$ac_tool_prefix"; then
     7920  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
     7921set dummy ${ac_tool_prefix}strip; ac_word=$2
     7922echo "$as_me:$LINENO: checking for $ac_word" >&5
     7923echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     7924if test "${ac_cv_prog_STRIP+set}" = set; then
     7925  echo $ECHO_N "(cached) $ECHO_C" >&6
     7926else
     7927  if test -n "$STRIP"; then
     7928  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
     7929else
     7930as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7931for as_dir in $PATH
     7932do
     7933  IFS=$as_save_IFS
     7934  test -z "$as_dir" && as_dir=.
     7935  for ac_exec_ext in '' $ac_executable_extensions; do
     7936  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     7937    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
     7938    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7939    break 2
     7940  fi
     7941done
     7942done
     7943
     7944fi
     7945fi
     7946STRIP=$ac_cv_prog_STRIP
     7947if test -n "$STRIP"; then
     7948  echo "$as_me:$LINENO: result: $STRIP" >&5
     7949echo "${ECHO_T}$STRIP" >&6
     7950else
     7951  echo "$as_me:$LINENO: result: no" >&5
     7952echo "${ECHO_T}no" >&6
     7953fi
     7954
     7955fi
     7956if test -z "$ac_cv_prog_STRIP"; then
     7957  ac_ct_STRIP=$STRIP
     7958  # Extract the first word of "strip", so it can be a program name with args.
     7959set dummy strip; ac_word=$2
     7960echo "$as_me:$LINENO: checking for $ac_word" >&5
     7961echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     7962if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
     7963  echo $ECHO_N "(cached) $ECHO_C" >&6
     7964else
     7965  if test -n "$ac_ct_STRIP"; then
     7966  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
     7967else
     7968as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7969for as_dir in $PATH
     7970do
     7971  IFS=$as_save_IFS
     7972  test -z "$as_dir" && as_dir=.
     7973  for ac_exec_ext in '' $ac_executable_extensions; do
     7974  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     7975    ac_cv_prog_ac_ct_STRIP="strip"
     7976    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7977    break 2
     7978  fi
     7979done
     7980done
     7981
     7982  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
     7983fi
     7984fi
     7985ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
     7986if test -n "$ac_ct_STRIP"; then
     7987  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
     7988echo "${ECHO_T}$ac_ct_STRIP" >&6
     7989else
     7990  echo "$as_me:$LINENO: result: no" >&5
     7991echo "${ECHO_T}no" >&6
     7992fi
     7993
     7994  STRIP=$ac_ct_STRIP
     7995else
     7996  STRIP="$ac_cv_prog_STRIP"
     7997fi
     7998
     7999
     8000old_CC="$CC"
     8001old_CFLAGS="$CFLAGS"
     8002
     8003# Set sane defaults for various variables
     8004test -z "$AR" && AR=ar
     8005test -z "$AR_FLAGS" && AR_FLAGS=cru
     8006test -z "$AS" && AS=as
     8007test -z "$CC" && CC=cc
     8008test -z "$LTCC" && LTCC=$CC
     8009test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
     8010test -z "$DLLTOOL" && DLLTOOL=dlltool
     8011test -z "$LD" && LD=ld
     8012test -z "$LN_S" && LN_S="ln -s"
     8013test -z "$MAGIC_CMD" && MAGIC_CMD=file
     8014test -z "$NM" && NM=nm
     8015test -z "$SED" && SED=sed
     8016test -z "$OBJDUMP" && OBJDUMP=objdump
     8017test -z "$RANLIB" && RANLIB=:
     8018test -z "$STRIP" && STRIP=:
     8019test -z "$ac_objext" && ac_objext=o
     8020
     8021# Determine commands to create old-style static archives.
     8022old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
     8023old_postinstall_cmds='chmod 644 $oldlib'
     8024old_postuninstall_cmds=
     8025
     8026if test -n "$RANLIB"; then
     8027  case $host_os in
     8028  openbsd*)
     8029    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
     8030    ;;
     8031  *)
     8032    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
     8033    ;;
     8034  esac
     8035  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
     8036fi
     8037
     8038for cc_temp in $compiler""; do
     8039  case $cc_temp in
     8040    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
     8041    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
     8042    \-*) ;;
     8043    *) break;;
     8044  esac
     8045done
     8046cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
     8047
     8048
     8049# Only perform the check for file, if the check method requires it
     8050case $deplibs_check_method in
     8051file_magic*)
     8052  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
     8053    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
     8054echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
     8055if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
     8056  echo $ECHO_N "(cached) $ECHO_C" >&6
     8057else
     8058  case $MAGIC_CMD in
     8059[\\/*] |  ?:[\\/]*)
     8060  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
     8061  ;;
     8062*)
     8063  lt_save_MAGIC_CMD="$MAGIC_CMD"
     8064  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     8065  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
     8066  for ac_dir in $ac_dummy; do
     8067    IFS="$lt_save_ifs"
     8068    test -z "$ac_dir" && ac_dir=.
     8069    if test -f $ac_dir/${ac_tool_prefix}file; then
     8070      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
     8071      if test -n "$file_magic_test_file"; then
     8072        case $deplibs_check_method in
     8073        "file_magic "*)
     8074          file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
     8075          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
     8076          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
     8077            $EGREP "$file_magic_regex" > /dev/null; then
     8078            :
     8079          else
     8080            cat <<EOF 1>&2
     8081
     8082*** Warning: the command libtool uses to detect shared libraries,
     8083*** $file_magic_cmd, produces output that libtool cannot recognize.
     8084*** The result is that libtool may fail to recognize shared libraries
     8085*** as such.  This will affect the creation of libtool libraries that
     8086*** depend on shared libraries, but programs linked with such libtool
     8087*** libraries will work regardless of this problem.  Nevertheless, you
     8088*** may want to report the problem to your system manager and/or to
     8089*** bug-libtool@gnu.org
     8090
     8091EOF
     8092          fi ;;
     8093        esac
     8094      fi
     8095      break
     8096    fi
     8097  done
     8098  IFS="$lt_save_ifs"
     8099  MAGIC_CMD="$lt_save_MAGIC_CMD"
     8100  ;;
     8101esac
     8102fi
     8103
     8104MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
     8105if test -n "$MAGIC_CMD"; then
     8106  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
     8107echo "${ECHO_T}$MAGIC_CMD" >&6
     8108else
     8109  echo "$as_me:$LINENO: result: no" >&5
     8110echo "${ECHO_T}no" >&6
     8111fi
     8112
     8113if test -z "$lt_cv_path_MAGIC_CMD"; then
     8114  if test -n "$ac_tool_prefix"; then
     8115    echo "$as_me:$LINENO: checking for file" >&5
     8116echo $ECHO_N "checking for file... $ECHO_C" >&6
     8117if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
     8118  echo $ECHO_N "(cached) $ECHO_C" >&6
     8119else
     8120  case $MAGIC_CMD in
     8121[\\/*] |  ?:[\\/]*)
     8122  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
     8123  ;;
     8124*)
     8125  lt_save_MAGIC_CMD="$MAGIC_CMD"
     8126  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
     8127  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
     8128  for ac_dir in $ac_dummy; do
     8129    IFS="$lt_save_ifs"
     8130    test -z "$ac_dir" && ac_dir=.
     8131    if test -f $ac_dir/file; then
     8132      lt_cv_path_MAGIC_CMD="$ac_dir/file"
     8133      if test -n "$file_magic_test_file"; then
     8134        case $deplibs_check_method in
     8135        "file_magic "*)
     8136          file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
     8137          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
     8138          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
     8139            $EGREP "$file_magic_regex" > /dev/null; then
     8140            :
     8141          else
     8142            cat <<EOF 1>&2
     8143
     8144*** Warning: the command libtool uses to detect shared libraries,
     8145*** $file_magic_cmd, produces output that libtool cannot recognize.
     8146*** The result is that libtool may fail to recognize shared libraries
     8147*** as such.  This will affect the creation of libtool libraries that
     8148*** depend on shared libraries, but programs linked with such libtool
     8149*** libraries will work regardless of this problem.  Nevertheless, you
     8150*** may want to report the problem to your system manager and/or to
     8151*** bug-libtool@gnu.org
     8152
     8153EOF
     8154          fi ;;
     8155        esac
     8156      fi
     8157      break
     8158    fi
     8159  done
     8160  IFS="$lt_save_ifs"
     8161  MAGIC_CMD="$lt_save_MAGIC_CMD"
     8162  ;;
     8163esac
     8164fi
     8165
     8166MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
     8167if test -n "$MAGIC_CMD"; then
     8168  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
     8169echo "${ECHO_T}$MAGIC_CMD" >&6
     8170else
     8171  echo "$as_me:$LINENO: result: no" >&5
     8172echo "${ECHO_T}no" >&6
     8173fi
     8174
     8175  else
     8176    MAGIC_CMD=:
     8177  fi
     8178fi
     8179
     8180  fi
     8181  ;;
     8182esac
     8183
     8184enable_dlopen=no
     8185enable_win32_dll=no
     8186
     8187# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
     8188if test "${enable_libtool_lock+set}" = set; then
     8189  enableval="$enable_libtool_lock"
     8190
     8191fi;
     8192test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
     8193
     8194
     8195# Check whether --with-pic or --without-pic was given.
     8196if test "${with_pic+set}" = set; then
     8197  withval="$with_pic"
     8198  pic_mode="$withval"
     8199else
     8200  pic_mode=default
     8201fi;
     8202test -z "$pic_mode" && pic_mode=default
     8203
     8204# Use C for the default configuration in the libtool script
     8205tagname=
     8206lt_save_CC="$CC"
     8207ac_ext=c
     8208ac_cpp='$CPP $CPPFLAGS'
     8209ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     8210ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     8211ac_compiler_gnu=$ac_cv_c_compiler_gnu
     8212
     8213
     8214# Source file extension for C test sources.
     8215ac_ext=c
     8216
     8217# Object file extension for compiled C test sources.
     8218objext=o
     8219objext=$objext
     8220
     8221# Code to be used in simple compile tests
     8222lt_simple_compile_test_code="int some_variable = 0;\n"
     8223
     8224# Code to be used in simple link tests
     8225lt_simple_link_test_code='int main(){return(0);}\n'
     8226
     8227
     8228# If no C compiler was specified, use CC.
     8229LTCC=${LTCC-"$CC"}
     8230
     8231# If no C compiler flags were specified, use CFLAGS.
     8232LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
     8233
     8234# Allow CC to be a program name with arguments.
     8235compiler=$CC
     8236
     8237
     8238# save warnings/boilerplate of simple test code
     8239ac_outfile=conftest.$ac_objext
     8240printf "$lt_simple_compile_test_code" >conftest.$ac_ext
     8241eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
     8242_lt_compiler_boilerplate=`cat conftest.err`
     8243$rm conftest*
     8244
     8245ac_outfile=conftest.$ac_objext
     8246printf "$lt_simple_link_test_code" >conftest.$ac_ext
     8247eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
     8248_lt_linker_boilerplate=`cat conftest.err`
     8249$rm conftest*
     8250
     8251
     8252## CAVEAT EMPTOR:
     8253## There is no encapsulation within the following macros, do not change
     8254## the running order or otherwise move them around unless you know exactly
     8255## what you are doing...
     8256
     8257lt_prog_compiler_no_builtin_flag=
     8258
     8259if test "$GCC" = yes; then
     8260  lt_prog_compiler_no_builtin_flag=' -fno-builtin'
     8261
     8262
     8263echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
     8264echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6
     8265if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
     8266  echo $ECHO_N "(cached) $ECHO_C" >&6
     8267else
     8268  lt_cv_prog_compiler_rtti_exceptions=no
     8269  ac_outfile=conftest.$ac_objext
     8270   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
     8271   lt_compiler_flag="-fno-rtti -fno-exceptions"
     8272   # Insert the option either (1) after the last *FLAGS variable, or
     8273   # (2) before a word containing "conftest.", or (3) at the end.
     8274   # Note that $ac_compile itself does not contain backslashes and begins
     8275   # with a dollar sign (not a hyphen), so the echo should work correctly.
     8276   # The option is referenced via a variable to avoid confusing sed.
     8277   lt_compile=`echo "$ac_compile" | $SED \
     8278   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     8279   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     8280   -e 's:$: $lt_compiler_flag:'`
     8281   (eval echo "\"\$as_me:8281: $lt_compile\"" >&5)
     8282   (eval "$lt_compile" 2>conftest.err)
     8283   ac_status=$?
     8284   cat conftest.err >&5
     8285   echo "$as_me:8285: \$? = $ac_status" >&5
     8286   if (exit $ac_status) && test -s "$ac_outfile"; then
     8287     # The compiler can only warn and ignore the option if not recognized
     8288     # So say no if there are warnings other than the usual output.
     8289     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
     8290     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     8291     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
     8292       lt_cv_prog_compiler_rtti_exceptions=yes
     8293     fi
     8294   fi
     8295   $rm conftest*
     8296
     8297fi
     8298echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
     8299echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6
     8300
     8301if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
     8302    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
     8303else
     8304    :
     8305fi
     8306
     8307fi
     8308
     8309lt_prog_compiler_wl=
     8310lt_prog_compiler_pic=
     8311lt_prog_compiler_static=
     8312
     8313echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
     8314echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
     8315
     8316  if test "$GCC" = yes; then
     8317    lt_prog_compiler_wl='-Wl,'
     8318    lt_prog_compiler_static='-static'
     8319
     8320    case $host_os in
     8321      aix*)
     8322      # All AIX code is PIC.
     8323      if test "$host_cpu" = ia64; then
     8324        # AIX 5 now supports IA64 processor
     8325        lt_prog_compiler_static='-Bstatic'
     8326      fi
     8327      ;;
     8328
     8329    amigaos*)
     8330      # FIXME: we need at least 68020 code to build shared libraries, but
     8331      # adding the `-m68020' flag to GCC prevents building anything better,
     8332      # like `-m68040'.
     8333      lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
     8334      ;;
     8335
     8336    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
     8337      # PIC is the default for these OSes.
     8338      ;;
     8339
     8340    mingw* | pw32* | os2*)
     8341      # This hack is so that the source file can tell whether it is being
     8342      # built for inclusion in a dll (and should export symbols for example).
     8343      lt_prog_compiler_pic='-DDLL_EXPORT'
     8344      ;;
     8345
     8346    darwin* | rhapsody*)
     8347      # PIC is the default on this platform
     8348      # Common symbols not allowed in MH_DYLIB files
     8349      lt_prog_compiler_pic='-fno-common'
     8350      ;;
     8351
     8352    interix3*)
     8353      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
     8354      # Instead, we relocate shared libraries at runtime.
     8355      ;;
     8356
     8357    msdosdjgpp*)
     8358      # Just because we use GCC doesn't mean we suddenly get shared libraries
     8359      # on systems that don't support them.
     8360      lt_prog_compiler_can_build_shared=no
     8361      enable_shared=no
     8362      ;;
     8363
     8364    sysv4*MP*)
     8365      if test -d /usr/nec; then
     8366        lt_prog_compiler_pic=-Kconform_pic
     8367      fi
     8368      ;;
     8369
     8370    hpux*)
     8371      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
     8372      # not for PA HP-UX.
     8373      case $host_cpu in
     8374      hppa*64*|ia64*)
     8375        # +Z the default
     8376        ;;
     8377      *)
     8378        lt_prog_compiler_pic='-fPIC'
     8379        ;;
     8380      esac
     8381      ;;
     8382
     8383    *)
     8384      lt_prog_compiler_pic='-fPIC'
     8385      ;;
     8386    esac
     8387  else
     8388    # PORTME Check for flag to pass linker flags through the system compiler.
     8389    case $host_os in
     8390    aix*)
     8391      lt_prog_compiler_wl='-Wl,'
     8392      if test "$host_cpu" = ia64; then
     8393        # AIX 5 now supports IA64 processor
     8394        lt_prog_compiler_static='-Bstatic'
     8395      else
     8396        lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
     8397      fi
     8398      ;;
     8399      darwin*)
     8400        # PIC is the default on this platform
     8401        # Common symbols not allowed in MH_DYLIB files
     8402       case $cc_basename in
     8403         xlc*)
     8404         lt_prog_compiler_pic='-qnocommon'
     8405         lt_prog_compiler_wl='-Wl,'
     8406         ;;
     8407       esac
     8408       ;;
     8409
     8410    mingw* | pw32* | os2*)
     8411      # This hack is so that the source file can tell whether it is being
     8412      # built for inclusion in a dll (and should export symbols for example).
     8413      lt_prog_compiler_pic='-DDLL_EXPORT'
     8414      ;;
     8415
     8416    hpux9* | hpux10* | hpux11*)
     8417      lt_prog_compiler_wl='-Wl,'
     8418      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
     8419      # not for PA HP-UX.
     8420      case $host_cpu in
     8421      hppa*64*|ia64*)
     8422        # +Z the default
     8423        ;;
     8424      *)
     8425        lt_prog_compiler_pic='+Z'
     8426        ;;
     8427      esac
     8428      # Is there a better lt_prog_compiler_static that works with the bundled CC?
     8429      lt_prog_compiler_static='${wl}-a ${wl}archive'
     8430      ;;
     8431
     8432    irix5* | irix6* | nonstopux*)
     8433      lt_prog_compiler_wl='-Wl,'
     8434      # PIC (with -KPIC) is the default.
     8435      lt_prog_compiler_static='-non_shared'
     8436      ;;
     8437
     8438    newsos6)
     8439      lt_prog_compiler_pic='-KPIC'
     8440      lt_prog_compiler_static='-Bstatic'
     8441      ;;
     8442
     8443    linux*)
     8444      case $cc_basename in
     8445      icc* | ecc*)
     8446        lt_prog_compiler_wl='-Wl,'
     8447        lt_prog_compiler_pic='-KPIC'
     8448        lt_prog_compiler_static='-static'
     8449        ;;
     8450      pgcc* | pgf77* | pgf90* | pgf95*)
     8451        # Portland Group compilers (*not* the Pentium gcc compiler,
     8452        # which looks to be a dead project)
     8453        lt_prog_compiler_wl='-Wl,'
     8454        lt_prog_compiler_pic='-fpic'
     8455        lt_prog_compiler_static='-Bstatic'
     8456        ;;
     8457      ccc*)
     8458        lt_prog_compiler_wl='-Wl,'
     8459        # All Alpha code is PIC.
     8460        lt_prog_compiler_static='-non_shared'
     8461        ;;
     8462      esac
     8463      ;;
     8464
     8465    osf3* | osf4* | osf5*)
     8466      lt_prog_compiler_wl='-Wl,'
     8467      # All OSF/1 code is PIC.
     8468      lt_prog_compiler_static='-non_shared'
     8469      ;;
     8470
     8471    solaris*)
     8472      lt_prog_compiler_pic='-KPIC'
     8473      lt_prog_compiler_static='-Bstatic'
     8474      case $cc_basename in
     8475      f77* | f90* | f95*)
     8476        lt_prog_compiler_wl='-Qoption ld ';;
     8477      *)
     8478        lt_prog_compiler_wl='-Wl,';;
     8479      esac
     8480      ;;
     8481
     8482    sunos4*)
     8483      lt_prog_compiler_wl='-Qoption ld '
     8484      lt_prog_compiler_pic='-PIC'
     8485      lt_prog_compiler_static='-Bstatic'
     8486      ;;
     8487
     8488    sysv4 | sysv4.2uw2* | sysv4.3*)
     8489      lt_prog_compiler_wl='-Wl,'
     8490      lt_prog_compiler_pic='-KPIC'
     8491      lt_prog_compiler_static='-Bstatic'
     8492      ;;
     8493
     8494    sysv4*MP*)
     8495      if test -d /usr/nec ;then
     8496        lt_prog_compiler_pic='-Kconform_pic'
     8497        lt_prog_compiler_static='-Bstatic'
     8498      fi
     8499      ;;
     8500
     8501    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
     8502      lt_prog_compiler_wl='-Wl,'
     8503      lt_prog_compiler_pic='-KPIC'
     8504      lt_prog_compiler_static='-Bstatic'
     8505      ;;
     8506
     8507    unicos*)
     8508      lt_prog_compiler_wl='-Wl,'
     8509      lt_prog_compiler_can_build_shared=no
     8510      ;;
     8511
     8512    uts4*)
     8513      lt_prog_compiler_pic='-pic'
     8514      lt_prog_compiler_static='-Bstatic'
     8515      ;;
     8516
     8517    *)
     8518      lt_prog_compiler_can_build_shared=no
     8519      ;;
     8520    esac
     8521  fi
     8522
     8523echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5
     8524echo "${ECHO_T}$lt_prog_compiler_pic" >&6
     8525
     8526#
     8527# Check to make sure the PIC flag actually works.
     8528#
     8529if test -n "$lt_prog_compiler_pic"; then
     8530
     8531echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
     8532echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic works... $ECHO_C" >&6
     8533if test "${lt_prog_compiler_pic_works+set}" = set; then
     8534  echo $ECHO_N "(cached) $ECHO_C" >&6
     8535else
     8536  lt_prog_compiler_pic_works=no
     8537  ac_outfile=conftest.$ac_objext
     8538   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
     8539   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
     8540   # Insert the option either (1) after the last *FLAGS variable, or
     8541   # (2) before a word containing "conftest.", or (3) at the end.
     8542   # Note that $ac_compile itself does not contain backslashes and begins
     8543   # with a dollar sign (not a hyphen), so the echo should work correctly.
     8544   # The option is referenced via a variable to avoid confusing sed.
     8545   lt_compile=`echo "$ac_compile" | $SED \
     8546   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     8547   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     8548   -e 's:$: $lt_compiler_flag:'`
     8549   (eval echo "\"\$as_me:8549: $lt_compile\"" >&5)
     8550   (eval "$lt_compile" 2>conftest.err)
     8551   ac_status=$?
     8552   cat conftest.err >&5
     8553   echo "$as_me:8553: \$? = $ac_status" >&5
     8554   if (exit $ac_status) && test -s "$ac_outfile"; then
     8555     # The compiler can only warn and ignore the option if not recognized
     8556     # So say no if there are warnings other than the usual output.
     8557     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
     8558     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     8559     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
     8560       lt_prog_compiler_pic_works=yes
     8561     fi
     8562   fi
     8563   $rm conftest*
     8564
     8565fi
     8566echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works" >&5
     8567echo "${ECHO_T}$lt_prog_compiler_pic_works" >&6
     8568
     8569if test x"$lt_prog_compiler_pic_works" = xyes; then
     8570    case $lt_prog_compiler_pic in
     8571     "" | " "*) ;;
     8572     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
     8573     esac
     8574else
     8575    lt_prog_compiler_pic=
     8576     lt_prog_compiler_can_build_shared=no
     8577fi
     8578
     8579fi
     8580case $host_os in
     8581  # For platforms which do not support PIC, -DPIC is meaningless:
     8582  *djgpp*)
     8583    lt_prog_compiler_pic=
     8584    ;;
     8585  *)
     8586    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
     8587    ;;
     8588esac
     8589
     8590#
     8591# Check to make sure the static flag actually works.
     8592#
     8593wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
     8594echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
     8595echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6
     8596if test "${lt_prog_compiler_static_works+set}" = set; then
     8597  echo $ECHO_N "(cached) $ECHO_C" >&6
     8598else
     8599  lt_prog_compiler_static_works=no
     8600   save_LDFLAGS="$LDFLAGS"
     8601   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
     8602   printf "$lt_simple_link_test_code" > conftest.$ac_ext
     8603   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
     8604     # The linker can only warn and ignore the option if not recognized
     8605     # So say no if there are warnings
     8606     if test -s conftest.err; then
     8607       # Append any errors to the config.log.
     8608       cat conftest.err 1>&5
     8609       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
     8610       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     8611       if diff conftest.exp conftest.er2 >/dev/null; then
     8612         lt_prog_compiler_static_works=yes
     8613       fi
     8614     else
     8615       lt_prog_compiler_static_works=yes
     8616     fi
     8617   fi
     8618   $rm conftest*
     8619   LDFLAGS="$save_LDFLAGS"
     8620
     8621fi
     8622echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works" >&5
     8623echo "${ECHO_T}$lt_prog_compiler_static_works" >&6
     8624
     8625if test x"$lt_prog_compiler_static_works" = xyes; then
     8626    :
     8627else
     8628    lt_prog_compiler_static=
     8629fi
     8630
     8631
     8632echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
     8633echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
     8634if test "${lt_cv_prog_compiler_c_o+set}" = set; then
     8635  echo $ECHO_N "(cached) $ECHO_C" >&6
     8636else
     8637  lt_cv_prog_compiler_c_o=no
     8638   $rm -r conftest 2>/dev/null
     8639   mkdir conftest
     8640   cd conftest
     8641   mkdir out
     8642   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
     8643
     8644   lt_compiler_flag="-o out/conftest2.$ac_objext"
     8645   # Insert the option either (1) after the last *FLAGS variable, or
     8646   # (2) before a word containing "conftest.", or (3) at the end.
     8647   # Note that $ac_compile itself does not contain backslashes and begins
     8648   # with a dollar sign (not a hyphen), so the echo should work correctly.
     8649   lt_compile=`echo "$ac_compile" | $SED \
     8650   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
     8651   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
     8652   -e 's:$: $lt_compiler_flag:'`
     8653   (eval echo "\"\$as_me:8653: $lt_compile\"" >&5)
     8654   (eval "$lt_compile" 2>out/conftest.err)
     8655   ac_status=$?
     8656   cat out/conftest.err >&5
     8657   echo "$as_me:8657: \$? = $ac_status" >&5
     8658   if (exit $ac_status) && test -s out/conftest2.$ac_objext
     8659   then
     8660     # The compiler can only warn and ignore the option if not recognized
     8661     # So say no if there are warnings
     8662     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
     8663     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     8664     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
     8665       lt_cv_prog_compiler_c_o=yes
     8666     fi
     8667   fi
     8668   chmod u+w . 2>&5
     8669   $rm conftest*
     8670   # SGI C++ compiler will create directory out/ii_files/ for
     8671   # template instantiation
     8672   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
     8673   $rm out/* && rmdir out
     8674   cd ..
     8675   rmdir conftest
     8676   $rm conftest*
     8677
     8678fi
     8679echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
     8680echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6
     8681
     8682
     8683hard_links="nottested"
     8684if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
     8685  # do not overwrite the value of need_locks provided by the user
     8686  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
     8687echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
     8688  hard_links=yes
     8689  $rm conftest*
     8690  ln conftest.a conftest.b 2>/dev/null && hard_links=no
     8691  touch conftest.a
     8692  ln conftest.a conftest.b 2>&5 || hard_links=no
     8693  ln conftest.a conftest.b 2>/dev/null && hard_links=no
     8694  echo "$as_me:$LINENO: result: $hard_links" >&5
     8695echo "${ECHO_T}$hard_links" >&6
     8696  if test "$hard_links" = no; then
     8697    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
     8698echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
     8699    need_locks=warn
     8700  fi
     8701else
     8702  need_locks=no
     8703fi
     8704
     8705echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
     8706echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
     8707
     8708  runpath_var=
     8709  allow_undefined_flag=
     8710  enable_shared_with_static_runtimes=no
     8711  archive_cmds=
     8712  archive_expsym_cmds=
     8713  old_archive_From_new_cmds=
     8714  old_archive_from_expsyms_cmds=
     8715  export_dynamic_flag_spec=
     8716  whole_archive_flag_spec=
     8717  thread_safe_flag_spec=
     8718  hardcode_libdir_flag_spec=
     8719  hardcode_libdir_flag_spec_ld=