Changeset 527 for trunk/configure


Ignore:
Timestamp:
Feb 1, 2007 4:24:46 PM (12 years ago)
Author:
andreasw
Message:

reran autotools with latest coin.m4 in stable; replaced make by $(MAKE); generate libtool in base directory

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/configure

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