Changeset 1697 for trunk/Clp


Ignore:
Timestamp:
Mar 6, 2011 2:42:59 PM (9 years ago)
Author:
forrest
Message:

sorry - did not mean to overwrite - bacl to Stefan's configure

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/configure

    r1696 r1697  
    473473#endif"
    474474
    475 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 build build_cpu build_vendor build_os ALWAYS_FALSE_TRUE ALWAYS_FALSE_FALSE have_svnversion CLP_SVN_REV COIN_CC_IS_CL_TRUE COIN_CC_IS_CL_FALSE CDEFS ADD_CFLAGS DBG_CFLAGS OPT_CFLAGS sol_cc_compiler CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT MPICC CXXDEFS ADD_CXXFLAGS DBG_CXXFLAGS OPT_CXXFLAGS CXX CXXFLAGS ac_ct_CXX COIN_CXX_IS_CL_TRUE COIN_CXX_IS_CL_FALSE MPICXX EGREP LN_S 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 ECHO AR ac_ct_AR RANLIB ac_ct_RANLIB CPP CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL ac_c_preproc_warn_flag ac_cxx_preproc_warn_flag RPATH_FLAGS LT_LDFLAGS PKG_CONFIG ac_pt_PKG_CONFIG COIN_HAS_PKGCONFIG_TRUE COIN_HAS_PKGCONFIG_FALSE COIN_PKG_CONFIG_PATH COIN_PKG_CONFIG_PATH_UNINSTALLED COINUTILS_LIBS COINUTILS_CFLAGS COINUTILS_DATA COINUTILS_DEPENDENCIES COINUTILS_LIBS_INSTALLED COINUTILS_CFLAGS_INSTALLED COINUTILS_DATA_INSTALLED CLPLIB_CFLAGS CLPLIB_LIBS CLPLIB_PCLIBS CLPLIB_PCREQUIRES CLPLIB_DEPENDENCIES CLPLIB_CFLAGS_INSTALLED CLPLIB_LIBS_INSTALLED COIN_HAS_COINUTILS_TRUE COIN_HAS_COINUTILS_FALSE OSI_LIBS OSI_CFLAGS OSI_DATA OSI_DEPENDENCIES OSI_LIBS_INSTALLED OSI_CFLAGS_INSTALLED OSI_DATA_INSTALLED OSICLPLIB_CFLAGS OSICLPLIB_LIBS OSICLPLIB_PCLIBS OSICLPLIB_PCREQUIRES OSICLPLIB_DEPENDENCIES OSICLPLIB_CFLAGS_INSTALLED OSICLPLIB_LIBS_INSTALLED COIN_HAS_OSI_TRUE COIN_HAS_OSI_FALSE OSITESTS_LIBS OSITESTS_CFLAGS OSITESTS_DATA OSITESTS_DEPENDENCIES OSITESTS_LIBS_INSTALLED OSITESTS_CFLAGS_INSTALLED OSITESTS_DATA_INSTALLED COIN_HAS_OSITESTS_TRUE COIN_HAS_OSITESTS_FALSE SAMPLE_LIBS SAMPLE_CFLAGS SAMPLE_DATA SAMPLE_DEPENDENCIES SAMPLE_LIBS_INSTALLED SAMPLE_CFLAGS_INSTALLED SAMPLE_DATA_INSTALLED COIN_HAS_SAMPLE_TRUE COIN_HAS_SAMPLE_FALSE NETLIB_LIBS NETLIB_CFLAGS NETLIB_DATA NETLIB_DEPENDENCIES NETLIB_LIBS_INSTALLED NETLIB_CFLAGS_INSTALLED NETLIB_DATA_INSTALLED COIN_HAS_NETLIB_TRUE COIN_HAS_NETLIB_FALSE coin_have_doxygen coin_doxy_usedot coin_doxy_tagname coin_doxy_logname coin_doxy_tagfiles coin_doxy_excludes LIBEXT VPATH_DISTCLEANFILES ABSBUILDDIR LIBOBJS LTLIBOBJS'
     475ac_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 ALWAYS_FALSE_TRUE ALWAYS_FALSE_FALSE have_svnversion CLP_SVN_REV COIN_CC_IS_CL_TRUE COIN_CC_IS_CL_FALSE CDEFS ADD_CFLAGS DBG_CFLAGS OPT_CFLAGS sol_cc_compiler CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT MPICC CXXDEFS ADD_CXXFLAGS DBG_CXXFLAGS OPT_CXXFLAGS CXX CXXFLAGS ac_ct_CXX COIN_CXX_IS_CL_TRUE COIN_CXX_IS_CL_FALSE MPICXX EGREP LN_S 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 ECHO AR ac_ct_AR RANLIB ac_ct_RANLIB CPP CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL ac_c_preproc_warn_flag ac_cxx_preproc_warn_flag RPATH_FLAGS LT_LDFLAGS PKG_CONFIG ac_pt_PKG_CONFIG COIN_HAS_PKGCONFIG_TRUE COIN_HAS_PKGCONFIG_FALSE COIN_PKG_CONFIG_PATH COIN_PKG_CONFIG_PATH_UNINSTALLED COINUTILS_LIBS COINUTILS_CFLAGS COINUTILS_DATA COINUTILS_DEPENDENCIES COINUTILS_LIBS_INSTALLED COINUTILS_CFLAGS_INSTALLED COINUTILS_DATA_INSTALLED CLPLIB_CFLAGS CLPLIB_LIBS CLPLIB_PCLIBS CLPLIB_PCREQUIRES CLPLIB_DEPENDENCIES CLPLIB_CFLAGS_INSTALLED CLPLIB_LIBS_INSTALLED COIN_HAS_COINUTILS_TRUE COIN_HAS_COINUTILS_FALSE OSI_LIBS OSI_CFLAGS OSI_DATA OSI_DEPENDENCIES OSI_LIBS_INSTALLED OSI_CFLAGS_INSTALLED OSI_DATA_INSTALLED OSICLPLIB_CFLAGS OSICLPLIB_LIBS OSICLPLIB_PCLIBS OSICLPLIB_PCREQUIRES OSICLPLIB_DEPENDENCIES OSICLPLIB_CFLAGS_INSTALLED OSICLPLIB_LIBS_INSTALLED COIN_HAS_OSI_TRUE COIN_HAS_OSI_FALSE OSITESTS_LIBS OSITESTS_CFLAGS OSITESTS_DATA OSITESTS_DEPENDENCIES OSITESTS_LIBS_INSTALLED OSITESTS_CFLAGS_INSTALLED OSITESTS_DATA_INSTALLED COIN_HAS_OSITESTS_TRUE COIN_HAS_OSITESTS_FALSE SAMPLE_LIBS SAMPLE_CFLAGS SAMPLE_DATA SAMPLE_DEPENDENCIES SAMPLE_LIBS_INSTALLED SAMPLE_CFLAGS_INSTALLED SAMPLE_DATA_INSTALLED COIN_HAS_SAMPLE_TRUE COIN_HAS_SAMPLE_FALSE NETLIB_LIBS NETLIB_CFLAGS NETLIB_DATA NETLIB_DEPENDENCIES NETLIB_LIBS_INSTALLED NETLIB_CFLAGS_INSTALLED NETLIB_DATA_INSTALLED COIN_HAS_NETLIB_TRUE COIN_HAS_NETLIB_FALSE AMDINCDIR AMDLIB COIN_HAS_AMD_TRUE COIN_HAS_AMD_FALSE CHOLMODINCDIR CHOLMODLIB COIN_HAS_CHOLMOD_TRUE COIN_HAS_CHOLMOD_FALSE GLPK_LIBS GLPK_CFLAGS GLPK_DATA GLPK_DEPENDENCIES GLPK_LIBS_INSTALLED GLPK_CFLAGS_INSTALLED GLPK_DATA_INSTALLED COIN_HAS_GLPK_TRUE COIN_HAS_GLPK_FALSE MUMPS_LIBS MUMPS_CFLAGS MUMPS_DATA MUMPS_DEPENDENCIES MUMPS_LIBS_INSTALLED MUMPS_CFLAGS_INSTALLED MUMPS_DATA_INSTALLED COIN_HAS_MUMPS_TRUE COIN_HAS_MUMPS_FALSE ADD_FFLAGS DBG_FFLAGS OPT_FFLAGS MPIF77 FLIBS BLAS_LIBS BLAS_CFLAGS BLAS_DATA BLAS_DEPENDENCIES BLAS_LIBS_INSTALLED BLAS_CFLAGS_INSTALLED BLAS_DATA_INSTALLED COIN_HAS_BLAS_TRUE COIN_HAS_BLAS_FALSE COIN_HAS_WSMP_TRUE COIN_HAS_WSMP_FALSE coin_have_doxygen coin_doxy_usedot coin_doxy_tagname coin_doxy_logname coin_doxy_tagfiles coin_doxy_excludes LIBEXT VPATH_DISTCLEANFILES ABSBUILDDIR LIBOBJS LTLIBOBJS'
    476476ac_subst_files=''
    477477
     
    998998ac_cv_env_PKG_CONFIG_set=${PKG_CONFIG+set}
    999999ac_cv_env_PKG_CONFIG_value=$PKG_CONFIG
     1000ac_env_ADD_FFLAGS_set=${ADD_FFLAGS+set}
     1001ac_env_ADD_FFLAGS_value=$ADD_FFLAGS
     1002ac_cv_env_ADD_FFLAGS_set=${ADD_FFLAGS+set}
     1003ac_cv_env_ADD_FFLAGS_value=$ADD_FFLAGS
     1004ac_env_DBG_FFLAGS_set=${DBG_FFLAGS+set}
     1005ac_env_DBG_FFLAGS_value=$DBG_FFLAGS
     1006ac_cv_env_DBG_FFLAGS_set=${DBG_FFLAGS+set}
     1007ac_cv_env_DBG_FFLAGS_value=$DBG_FFLAGS
     1008ac_env_OPT_FFLAGS_set=${OPT_FFLAGS+set}
     1009ac_env_OPT_FFLAGS_value=$OPT_FFLAGS
     1010ac_cv_env_OPT_FFLAGS_set=${OPT_FFLAGS+set}
     1011ac_cv_env_OPT_FFLAGS_value=$OPT_FFLAGS
     1012ac_env_MPIF77_set=${MPIF77+set}
     1013ac_env_MPIF77_value=$MPIF77
     1014ac_cv_env_MPIF77_set=${MPIF77+set}
     1015ac_cv_env_MPIF77_value=$MPIF77
    10001016
    10011017#
     
    11011117                          whether to deduce Makefile dependencies from package
    11021118                          linker flags (default: yes)
     1119  --enable-amd-libcheck use disable-amd-libcheck to skip the link
     1120                          check at configuration time
     1121  --enable-cholmod-libcheck
     1122                          use disable-cholmod-libcheck to skip the
     1123                          link check at configuration time
    11031124  --enable-gnu-packages   compile with GNU packages (disabled by default)
    11041125
     
    11341155  --with-netlib-incdir directory with header files for using package Netlib
    11351156  --with-netlib-datadir directory with data files for using package Netlib
     1157  --with-amd-incdir specify the header file directory for library AMD
     1158  --with-amd-lib specify the flags used to link with the library AMD
     1159  --with-cholmod-incdir specify the header file directory for library CHOLMOD
     1160  --with-cholmod-lib specify the flags used to link with the library CHOLMOD
     1161  --with-glpk-lib linker flags for using package Glpk
     1162  --with-glpk-incdir directory with header files for using package Glpk
     1163  --with-glpk-datadir directory with data files for using package Glpk
     1164  --with-mumps-lib linker flags for using package Mumps
     1165  --with-mumps-incdir directory with header files for using package Mumps
     1166  --with-mumps-datadir directory with data files for using package Mumps
    11361167  --with-wsmp             specify WSMP library
     1168  --with-blas             specify BLAS library (or BUILD to enforce use of
     1169                          ThirdParty/Blas)
     1170
     1171  --with-blas-lib linker flags for using package Blas
     1172  --with-blas-incdir directory with header files for using package Blas
     1173  --with-blas-datadir directory with data files for using package Blas
    11371174  --with-dot              use dot (from graphviz) when creating documentation
    11381175                          with doxygen if available; --without-dot to disable
     
    11651202  FFLAGS      Fortran 77 compiler flags
    11661203  PKG_CONFIG  path to pkg-config utility
     1204  ADD_FFLAGS  Additional Fortran compiler options
     1205  DBG_FFLAGS  Debug Fortran compiler options
     1206  OPT_FFLAGS  Optimize Fortran compiler options
     1207  MPIF77      Fortran MPI Compiler
    11671208
    11681209Use these variables to override the choices made by `configure' or to help
     
    17221763coin_projectdir=yes
    17231764
    1724 # Set the project's version number
     1765# Set the project's version numbers
    17251766
    17261767
    17271768cat >>confdefs.h <<_ACEOF
    17281769#define CLP_VERSION "$PACKAGE_VERSION"
     1770_ACEOF
     1771
     1772
     1773  coin_majorver=`echo $PACKAGE_VERSION | sed -n -e 's/^\([0-9]*\).*/\1/gp'`
     1774  coin_minorver=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.\([0-9]*\).*/\1/gp'`
     1775  coin_releasever=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/gp'`
     1776  if test "x$coin_majorver" = x ; then coin_majorver=9999 ; fi
     1777  if test "x$coin_minorver" = x ; then coin_minorver=9999 ; fi
     1778  if test "x$coin_releasever" = x ; then coin_releasever=9999 ; fi
     1779
     1780cat >>confdefs.h <<_ACEOF
     1781#define CLP_VERSION_MAJOR $coin_majorver
     1782_ACEOF
     1783
     1784
     1785cat >>confdefs.h <<_ACEOF
     1786#define CLP_VERSION_MINOR $coin_minorver
     1787_ACEOF
     1788
     1789
     1790cat >>confdefs.h <<_ACEOF
     1791#define CLP_VERSION_RELEASE $coin_releasever
    17291792_ACEOF
    17301793
     
    28202883        coin_add_cflags="-pipe"
    28212884        coin_dbg_cflags="-g"
    2822         coin_warn_cflags="-Wimplicit -Wparentheses -Wsequence-point -Wreturn-type -Wcast-qual -Wall -Wno-unknown-pragmas"
     2885        coin_warn_cflags="-Wimplicit -Wparentheses -Wsequence-point -Wreturn-type -Wcast-qual -Wall -Wno-unknown-pragmas -Wno-long-long"
    28232886        case $build in
    28242887          *-darwin*)
     
    37473810        coin_add_cxxflags="-pipe"
    37483811        coin_dbg_cxxflags="-g"
    3749         coin_warn_cxxflags="-Wimplicit -Wparentheses -Wreturn-type -Wcast-qual -Wall -Wpointer-arith -Wwrite-strings -Wconversion -Wno-unknown-pragmas"
     3812        coin_warn_cxxflags="-Wimplicit -Wparentheses -Wreturn-type -Wcast-qual -Wall -Wpointer-arith -Wwrite-strings -Wconversion -Wno-unknown-pragmas -Wno-long-long"
    37503813        case $build in
    37513814          *-darwin*)
     
    59155978*-*-irix6*)
    59165979  # Find out which ABI we are using.
    5917   echo '#line 5917 "configure"' > conftest.$ac_ext
     5980  echo '#line 5980 "configure"' > conftest.$ac_ext
    59185981  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
    59195982  (eval $ac_compile) 2>&5
     
    70497112
    70507113# Provide some information about the compiler.
    7051 echo "$as_me:7051:" \
     7114echo "$as_me:7114:" \
    70527115     "checking for Fortran 77 compiler version" >&5
    70537116ac_compiler=`set X $ac_compile; echo $2`
     
    81168179   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    81178180   -e 's:$: $lt_compiler_flag:'`
    8118    (eval echo "\"\$as_me:8118: $lt_compile\"" >&5)
     8181   (eval echo "\"\$as_me:8181: $lt_compile\"" >&5)
    81198182   (eval "$lt_compile" 2>conftest.err)
    81208183   ac_status=$?
    81218184   cat conftest.err >&5
    8122    echo "$as_me:8122: \$? = $ac_status" >&5
     8185   echo "$as_me:8185: \$? = $ac_status" >&5
    81238186   if (exit $ac_status) && test -s "$ac_outfile"; then
    81248187     # The compiler can only warn and ignore the option if not recognized
     
    83848447   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    83858448   -e 's:$: $lt_compiler_flag:'`
    8386    (eval echo "\"\$as_me:8386: $lt_compile\"" >&5)
     8449   (eval echo "\"\$as_me:8449: $lt_compile\"" >&5)
    83878450   (eval "$lt_compile" 2>conftest.err)
    83888451   ac_status=$?
    83898452   cat conftest.err >&5
    8390    echo "$as_me:8390: \$? = $ac_status" >&5
     8453   echo "$as_me:8453: \$? = $ac_status" >&5
    83918454   if (exit $ac_status) && test -s "$ac_outfile"; then
    83928455     # The compiler can only warn and ignore the option if not recognized
     
    84888551   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    84898552   -e 's:$: $lt_compiler_flag:'`
    8490    (eval echo "\"\$as_me:8490: $lt_compile\"" >&5)
     8553   (eval echo "\"\$as_me:8553: $lt_compile\"" >&5)
    84918554   (eval "$lt_compile" 2>out/conftest.err)
    84928555   ac_status=$?
    84938556   cat out/conftest.err >&5
    8494    echo "$as_me:8494: \$? = $ac_status" >&5
     8557   echo "$as_me:8557: \$? = $ac_status" >&5
    84958558   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    84968559   then
     
    1083310896  lt_status=$lt_dlunknown
    1083410897  cat > conftest.$ac_ext <<EOF
    10835 #line 10835 "configure"
     10898#line 10898 "configure"
    1083610899#include "confdefs.h"
    1083710900
     
    1093310996  lt_status=$lt_dlunknown
    1093410997  cat > conftest.$ac_ext <<EOF
    10935 #line 10935 "configure"
     10998#line 10998 "configure"
    1093610999#include "confdefs.h"
    1093711000
     
    1327713340   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1327813341   -e 's:$: $lt_compiler_flag:'`
    13279    (eval echo "\"\$as_me:13279: $lt_compile\"" >&5)
     13342   (eval echo "\"\$as_me:13342: $lt_compile\"" >&5)
    1328013343   (eval "$lt_compile" 2>conftest.err)
    1328113344   ac_status=$?
    1328213345   cat conftest.err >&5
    13283    echo "$as_me:13283: \$? = $ac_status" >&5
     13346   echo "$as_me:13346: \$? = $ac_status" >&5
    1328413347   if (exit $ac_status) && test -s "$ac_outfile"; then
    1328513348     # The compiler can only warn and ignore the option if not recognized
     
    1338113444   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1338213445   -e 's:$: $lt_compiler_flag:'`
    13383    (eval echo "\"\$as_me:13383: $lt_compile\"" >&5)
     13446   (eval echo "\"\$as_me:13446: $lt_compile\"" >&5)
    1338413447   (eval "$lt_compile" 2>out/conftest.err)
    1338513448   ac_status=$?
    1338613449   cat out/conftest.err >&5
    13387    echo "$as_me:13387: \$? = $ac_status" >&5
     13450   echo "$as_me:13450: \$? = $ac_status" >&5
    1338813451   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    1338913452   then
     
    1495115014   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1495215015   -e 's:$: $lt_compiler_flag:'`
    14953    (eval echo "\"\$as_me:14953: $lt_compile\"" >&5)
     15016   (eval echo "\"\$as_me:15016: $lt_compile\"" >&5)
    1495415017   (eval "$lt_compile" 2>conftest.err)
    1495515018   ac_status=$?
    1495615019   cat conftest.err >&5
    14957    echo "$as_me:14957: \$? = $ac_status" >&5
     15020   echo "$as_me:15020: \$? = $ac_status" >&5
    1495815021   if (exit $ac_status) && test -s "$ac_outfile"; then
    1495915022     # The compiler can only warn and ignore the option if not recognized
     
    1505515118   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1505615119   -e 's:$: $lt_compiler_flag:'`
    15057    (eval echo "\"\$as_me:15057: $lt_compile\"" >&5)
     15120   (eval echo "\"\$as_me:15120: $lt_compile\"" >&5)
    1505815121   (eval "$lt_compile" 2>out/conftest.err)
    1505915122   ac_status=$?
    1506015123   cat out/conftest.err >&5
    15061    echo "$as_me:15061: \$? = $ac_status" >&5
     15124   echo "$as_me:15124: \$? = $ac_status" >&5
    1506215125   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    1506315126   then
     
    1726217325   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1726317326   -e 's:$: $lt_compiler_flag:'`
    17264    (eval echo "\"\$as_me:17264: $lt_compile\"" >&5)
     17327   (eval echo "\"\$as_me:17327: $lt_compile\"" >&5)
    1726517328   (eval "$lt_compile" 2>conftest.err)
    1726617329   ac_status=$?
    1726717330   cat conftest.err >&5
    17268    echo "$as_me:17268: \$? = $ac_status" >&5
     17331   echo "$as_me:17331: \$? = $ac_status" >&5
    1726917332   if (exit $ac_status) && test -s "$ac_outfile"; then
    1727017333     # The compiler can only warn and ignore the option if not recognized
     
    1753017593   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1753117594   -e 's:$: $lt_compiler_flag:'`
    17532    (eval echo "\"\$as_me:17532: $lt_compile\"" >&5)
     17595   (eval echo "\"\$as_me:17595: $lt_compile\"" >&5)
    1753317596   (eval "$lt_compile" 2>conftest.err)
    1753417597   ac_status=$?
    1753517598   cat conftest.err >&5
    17536    echo "$as_me:17536: \$? = $ac_status" >&5
     17599   echo "$as_me:17599: \$? = $ac_status" >&5
    1753717600   if (exit $ac_status) && test -s "$ac_outfile"; then
    1753817601     # The compiler can only warn and ignore the option if not recognized
     
    1763417697   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1763517698   -e 's:$: $lt_compiler_flag:'`
    17636    (eval echo "\"\$as_me:17636: $lt_compile\"" >&5)
     17699   (eval echo "\"\$as_me:17699: $lt_compile\"" >&5)
    1763717700   (eval "$lt_compile" 2>out/conftest.err)
    1763817701   ac_status=$?
    1763917702   cat out/conftest.err >&5
    17640    echo "$as_me:17640: \$? = $ac_status" >&5
     17703   echo "$as_me:17703: \$? = $ac_status" >&5
    1764117704   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    1764217705   then
     
    2306023123#############################################################################
    2306123124
    23062 # WSMP
    23063 
    23064 # Check whether --with-wsmp or --without-wsmp was given.
    23065 if test "${with_wsmp+set}" = set; then
    23066   withval="$with_wsmp"
    23067   use_wsmp=$withval
    23068 else
    23069   use_wsmp=no
     23125# AMD from UFL
     23126
     23127  echo "$as_me:$LINENO: checking if user provides library for AMD" >&5
     23128echo $ECHO_N "checking if user provides library for AMD... $ECHO_C" >&6
     23129
     23130# Check for header file directory
     23131
     23132
     23133# Check whether --with-amd-incdir or --without-amd-incdir was given.
     23134if test "${with_amd_incdir+set}" = set; then
     23135  withval="$with_amd_incdir"
     23136  AMDINCDIR=`cd $withval; pwd`
    2307023137fi;
    2307123138
    23072 if test "$use_wsmp" != "no"; then
    23073   CLPLIB_LIBS="$use_wsmp $CLPLIB_LIBS"
    23074   CLPLIB_PCLIBS="$use_wsmp $CLPLIB_PCLIBS"
    23075 
    23076   defval=
    23077   echo "$as_me:$LINENO: checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp_)" >&5
    23078 echo $ECHO_N "checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp_)... $ECHO_C" >&6
    23079   cat >conftest.$ac_ext <<_ACEOF
     23139# Check for library directory
     23140
     23141
     23142# Check whether --with-amd-lib or --without-amd-lib was given.
     23143if test "${with_amd_lib+set}" = set; then
     23144  withval="$with_amd_lib"
     23145  AMDLIB=$withval
     23146fi;
     23147
     23148# Switch to disable library check if requested
     23149
     23150  # Check whether --enable-amd-libcheck or --disable-amd-libcheck was given.
     23151if test "${enable_amd_libcheck+set}" = set; then
     23152  enableval="$enable_amd_libcheck"
     23153  amd_libcheck=$enableval
     23154else
     23155  amd_libcheck=yes
     23156fi;
     23157
     23158# At this point, if we're going to use the library, both LBRYINCDIR and
     23159# LBRYLIB must be defined and not empty.
     23160
     23161  if test x"$AMDINCDIR" != x || test x"$AMDLIB" != x; then
     23162    if test x"$AMDINCDIR" = x || test x"$AMDLIB" = x; then
     23163      { { echo "$as_me:$LINENO: error: You need to specify both an include directory and link flags to use library AMD. Use --with-amd-incdir of environment variable $AMDINCDIR to specify the include directory. Use --with-amd-lib or environment variable $AMDLIB to specify link flags." >&5
     23164echo "$as_me: error: You need to specify both an include directory and link flags to use library AMD. Use --with-amd-incdir of environment variable $AMDINCDIR to specify the include directory. Use --with-amd-lib or environment variable $AMDLIB to specify link flags." >&2;}
     23165   { (exit 1); exit 1; }; }
     23166    fi
     23167    coin_has_amd=true
     23168    echo "$as_me:$LINENO: result: yes" >&5
     23169echo "${ECHO_T}yes" >&6
     23170  else
     23171    coin_has_amd=false
     23172    echo "$as_me:$LINENO: result: no" >&5
     23173echo "${ECHO_T}no" >&6
     23174  fi
     23175
     23176# If we have instructions for use, consider header and link checks.
     23177
     23178  if test $coin_has_amd = true; then
     23179
     23180# If argument 3 (file) is given, check for the file. Typically this will be a
     23181# header file, but that's not assumed.
     23182
     23183    if test -r $AMDINCDIR/amd.h; then
     23184
     23185  :
     23186else
     23187  { { echo "$as_me:$LINENO: error: Cannot find file amd.h in $AMDINCDIR" >&5
     23188echo "$as_me: error: Cannot find file amd.h in $AMDINCDIR" >&2;}
     23189   { (exit 1); exit 1; }; }
     23190  :
     23191fi
     23192
     23193
     23194# Now see if we can link the function. There are arguments for and against
     23195# assuming argument 3 is a header file declaring the function. A correct
     23196# function declaration is the main argument in favour. Having to cope with
     23197# possible dependencies or other oddities are the main arguments against.
     23198# Force the use of C as the best single choice amongst C++, C, and Fortran.
     23199# Obviously, this has limits.
     23200
     23201    if test x"$amd_libcheck" != xno; then
     23202           coin_save_LIBS="$LIBS"
     23203           LIBS="$AMDLIB "
     23204           coin_AMD_link=no
     23205           ac_ext=c
     23206ac_cpp='$CPP $CPPFLAGS'
     23207ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23208ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23209ac_compiler_gnu=$ac_cv_c_compiler_gnu
     23210
     23211           for fnm in amd_defaults ; do
     23212             echo "$as_me:$LINENO: checking whether symbol $fnm is available with AMD" >&5
     23213echo $ECHO_N "checking whether symbol $fnm is available with AMD... $ECHO_C" >&6
     23214             cat >conftest.$ac_ext <<_ACEOF
    2308023215/* confdefs.h.  */
    2308123216_ACEOF
     
    2308723222main ()
    2308823223{
    23089 wssmp_()
     23224$fnm()
    2309023225  ;
    2309123226  return 0;
     
    2311623251  echo "$as_me:$LINENO: result: yes" >&5
    2311723252echo "${ECHO_T}yes" >&6
    23118                defval=2
     23253                  coin_AMD_link=yes
     23254                  break
    2311923255else
    2312023256  echo "$as_me: failed program was:" >&5
     
    2312623262rm -f conftest.err conftest.$ac_objext \
    2312723263      conftest$ac_exeext conftest.$ac_ext
    23128   if test "$defval" = ""; then
    23129     echo "$as_me:$LINENO: checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp)" >&5
    23130 echo $ECHO_N "checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp)... $ECHO_C" >&6
    23131     cat >conftest.$ac_ext <<_ACEOF
     23264           done
     23265           ac_ext=c
     23266ac_cpp='$CPP $CPPFLAGS'
     23267ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23268ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23269ac_compiler_gnu=$ac_cv_c_compiler_gnu
     23270
     23271           LIBS="$coin_save_LIBS"
     23272           if test x"$coin_AMD_link" != xyes ; then
     23273             { { echo "$as_me:$LINENO: error: Cannot find symbol(s) amd_defaults with AMD" >&5
     23274echo "$as_me: error: Cannot find symbol(s) amd_defaults with AMD" >&2;}
     23275   { (exit 1); exit 1; }; }
     23276           fi
     23277         fi
     23278
     23279
     23280# If we make it this far, we've verified the file and linked the function. Add
     23281# the necessary link flags to ClpLib_{PC}LIBS and define the preprocessor symbol
     23282# COIN_HAS_LBRY.
     23283
     23284
     23285      CLPLIB_LIBS="$AMDLIB $CLPLIB_LIBS"
     23286      CLPLIB_PCLIBS="$AMDLIB $CLPLIB_PCLIBS"
     23287      CLPLIB_LIBS_INSTALLED="$AMDLIB $CLPLIB_LIBS_INSTALLED"
     23288
     23289
     23290
     23291cat >>confdefs.h <<\_ACEOF
     23292#define COIN_HAS_AMD 1
     23293_ACEOF
     23294
     23295  fi
     23296
     23297# Arrange for configure to substitute LBRYINCDIR and LBRYLIB and create the
     23298# automake conditional. These actions must occur unconditionally.
     23299
     23300
     23301
     23302
     23303
     23304if test $coin_has_amd = true; then
     23305  COIN_HAS_AMD_TRUE=
     23306  COIN_HAS_AMD_FALSE='#'
     23307else
     23308  COIN_HAS_AMD_TRUE='#'
     23309  COIN_HAS_AMD_FALSE=
     23310fi
     23311
     23312
     23313
     23314# CHOLMOD from UFL
     23315# CHOLMOD requires AMD, which can be given by AMD_LIBS
     23316# CHOLMOD requires Blas and Lapack, which should be in COINUTILS_LIBS, if available
     23317coin_save_LIBS="$LIBS"
     23318LIBS="$LIBS $AMD_LIBS"
     23319
     23320  echo "$as_me:$LINENO: checking if user provides library for CHOLMOD" >&5
     23321echo $ECHO_N "checking if user provides library for CHOLMOD... $ECHO_C" >&6
     23322
     23323# Check for header file directory
     23324
     23325
     23326# Check whether --with-cholmod-incdir or --without-cholmod-incdir was given.
     23327if test "${with_cholmod_incdir+set}" = set; then
     23328  withval="$with_cholmod_incdir"
     23329  CHOLMODINCDIR=`cd $withval; pwd`
     23330fi;
     23331
     23332# Check for library directory
     23333
     23334
     23335# Check whether --with-cholmod-lib or --without-cholmod-lib was given.
     23336if test "${with_cholmod_lib+set}" = set; then
     23337  withval="$with_cholmod_lib"
     23338  CHOLMODLIB=$withval
     23339fi;
     23340
     23341# Switch to disable library check if requested
     23342
     23343  # Check whether --enable-cholmod-libcheck or --disable-cholmod-libcheck was given.
     23344if test "${enable_cholmod_libcheck+set}" = set; then
     23345  enableval="$enable_cholmod_libcheck"
     23346  cholmod_libcheck=$enableval
     23347else
     23348  cholmod_libcheck=yes
     23349fi;
     23350
     23351# At this point, if we're going to use the library, both LBRYINCDIR and
     23352# LBRYLIB must be defined and not empty.
     23353
     23354  if test x"$CHOLMODINCDIR" != x || test x"$CHOLMODLIB" != x; then
     23355    if test x"$CHOLMODINCDIR" = x || test x"$CHOLMODLIB" = x; then
     23356      { { echo "$as_me:$LINENO: error: You need to specify both an include directory and link flags to use library CHOLMOD. Use --with-cholmod-incdir of environment variable $CHOLMODINCDIR to specify the include directory. Use --with-cholmod-lib or environment variable $CHOLMODLIB to specify link flags." >&5
     23357echo "$as_me: error: You need to specify both an include directory and link flags to use library CHOLMOD. Use --with-cholmod-incdir of environment variable $CHOLMODINCDIR to specify the include directory. Use --with-cholmod-lib or environment variable $CHOLMODLIB to specify link flags." >&2;}
     23358   { (exit 1); exit 1; }; }
     23359    fi
     23360    coin_has_cholmod=true
     23361    echo "$as_me:$LINENO: result: yes" >&5
     23362echo "${ECHO_T}yes" >&6
     23363  else
     23364    coin_has_cholmod=false
     23365    echo "$as_me:$LINENO: result: no" >&5
     23366echo "${ECHO_T}no" >&6
     23367  fi
     23368
     23369# If we have instructions for use, consider header and link checks.
     23370
     23371  if test $coin_has_cholmod = true; then
     23372
     23373# If argument 3 (file) is given, check for the file. Typically this will be a
     23374# header file, but that's not assumed.
     23375
     23376    if test -r $CHOLMODINCDIR/cholmod.h; then
     23377
     23378  :
     23379else
     23380  { { echo "$as_me:$LINENO: error: Cannot find file cholmod.h in $CHOLMODINCDIR" >&5
     23381echo "$as_me: error: Cannot find file cholmod.h in $CHOLMODINCDIR" >&2;}
     23382   { (exit 1); exit 1; }; }
     23383  :
     23384fi
     23385
     23386
     23387# Now see if we can link the function. There are arguments for and against
     23388# assuming argument 3 is a header file declaring the function. A correct
     23389# function declaration is the main argument in favour. Having to cope with
     23390# possible dependencies or other oddities are the main arguments against.
     23391# Force the use of C as the best single choice amongst C++, C, and Fortran.
     23392# Obviously, this has limits.
     23393
     23394    if test x"$cholmod_libcheck" != xno; then
     23395           coin_save_LIBS="$LIBS"
     23396           LIBS="$CHOLMODLIB "
     23397           coin_CHOLMOD_link=no
     23398           ac_ext=c
     23399ac_cpp='$CPP $CPPFLAGS'
     23400ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23401ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23402ac_compiler_gnu=$ac_cv_c_compiler_gnu
     23403
     23404           for fnm in cholmod_start ; do
     23405             echo "$as_me:$LINENO: checking whether symbol $fnm is available with CHOLMOD" >&5
     23406echo $ECHO_N "checking whether symbol $fnm is available with CHOLMOD... $ECHO_C" >&6
     23407             cat >conftest.$ac_ext <<_ACEOF
    2313223408/* confdefs.h.  */
    2313323409_ACEOF
     
    2313923415main ()
    2314023416{
    23141 wssmp()
     23417$fnm()
    2314223418  ;
    2314323419  return 0;
     
    2316823444  echo "$as_me:$LINENO: result: yes" >&5
    2316923445echo "${ECHO_T}yes" >&6
    23170                  defval=3
     23446                  coin_CHOLMOD_link=yes
     23447                  break
    2317123448else
    2317223449  echo "$as_me: failed program was:" >&5
     
    2317523452echo "$as_me:$LINENO: result: no" >&5
    2317623453echo "${ECHO_T}no" >&6
     23454fi
     23455rm -f conftest.err conftest.$ac_objext \
     23456      conftest$ac_exeext conftest.$ac_ext
     23457           done
     23458           ac_ext=c
     23459ac_cpp='$CPP $CPPFLAGS'
     23460ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23461ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23462ac_compiler_gnu=$ac_cv_c_compiler_gnu
     23463
     23464           LIBS="$coin_save_LIBS"
     23465           if test x"$coin_CHOLMOD_link" != xyes ; then
     23466             { { echo "$as_me:$LINENO: error: Cannot find symbol(s) cholmod_start with CHOLMOD" >&5
     23467echo "$as_me: error: Cannot find symbol(s) cholmod_start with CHOLMOD" >&2;}
     23468   { (exit 1); exit 1; }; }
     23469           fi
     23470         fi
     23471
     23472
     23473# If we make it this far, we've verified the file and linked the function. Add
     23474# the necessary link flags to ClpLib_{PC}LIBS and define the preprocessor symbol
     23475# COIN_HAS_LBRY.
     23476
     23477
     23478      CLPLIB_LIBS="$CHOLMODLIB $CLPLIB_LIBS"
     23479      CLPLIB_PCLIBS="$CHOLMODLIB $CLPLIB_PCLIBS"
     23480      CLPLIB_LIBS_INSTALLED="$CHOLMODLIB $CLPLIB_LIBS_INSTALLED"
     23481
     23482
     23483
     23484cat >>confdefs.h <<\_ACEOF
     23485#define COIN_HAS_CHOLMOD 1
     23486_ACEOF
     23487
     23488  fi
     23489
     23490# Arrange for configure to substitute LBRYINCDIR and LBRYLIB and create the
     23491# automake conditional. These actions must occur unconditionally.
     23492
     23493
     23494
     23495
     23496
     23497if test $coin_has_cholmod = true; then
     23498  COIN_HAS_CHOLMOD_TRUE=
     23499  COIN_HAS_CHOLMOD_FALSE='#'
     23500else
     23501  COIN_HAS_CHOLMOD_TRUE='#'
     23502  COIN_HAS_CHOLMOD_FALSE=
     23503fi
     23504
     23505
     23506LIBS="$coin_save_LIBS"
     23507
     23508# Glpk also brings AMD
     23509if test $coin_has_cholmod = false -a $coin_has_amd = false ; then
     23510
     23511echo "$as_me:$LINENO: checking for COIN-OR package Glpk" >&5
     23512echo $ECHO_N "checking for COIN-OR package Glpk... $ECHO_C" >&6
     23513
     23514coin_has_glpk=notGiven
     23515
     23516# check if user wants to skip package in any case
     23517if test x"$COIN_SKIP_PROJECTS" != x; then
     23518  for dir in $COIN_SKIP_PROJECTS; do
     23519    if test $dir = "Glpk"; then
     23520      coin_has_glpk=skipping
     23521    fi
     23522  done
     23523fi
     23524
     23525GLPK_LIBS=
     23526GLPK_CFLAGS=
     23527GLPK_DATA=
     23528
     23529
     23530
     23531
     23532
     23533
     23534
     23535
     23536
     23537
     23538
     23539
     23540
     23541
     23542
     23543
     23544
     23545#check if user provided LIBS, CFLAGS, or DATA for package or disables use of package
     23546if test $coin_has_glpk != skipping; then
     23547
     23548# Check whether --with-m4_tolower(Glpk)-lib or --without-m4_tolower(Glpk)-lib was given.
     23549if test "${with_glpk_lib+set}" = set; then
     23550  withval="$with_glpk_lib"
     23551  if test "$withval" = no ; then
     23552       coin_has_glpk=skipping
     23553     else
     23554       coin_has_glpk=yes
     23555       GLPK_LIBS="$withval"
     23556
     23557         CLPLIB_PCLIBS="$withval $CLPLIB_PCLIBS"
     23558         CLPLIB_LIBS="$withval $CLPLIB_LIBS"
     23559
     23560       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     23561       if test -z "$PKG_CONFIG" ; then
     23562         GLPK_LIBS_INSTALLED="$withval"
     23563         CLPLIB_LIBS_INSTALLED="$withval $CLPLIB_LIBS_INSTALLED"
     23564       fi
     23565     fi
     23566
     23567fi;
     23568fi
     23569
     23570if test $coin_has_glpk != skipping; then
     23571
     23572# Check whether --with-m4_tolower(Glpk)-incdir or --without-m4_tolower(Glpk)-incdir was given.
     23573if test "${with_glpk_incdir+set}" = set; then
     23574  withval="$with_glpk_incdir"
     23575  if test "$withval" = no ; then
     23576       coin_has_glpk=skipping
     23577     else
     23578       coin_has_glpk=yes
     23579       GLPK_CFLAGS="-I`${CYGPATH_W} $withval`"
     23580       CLPLIB_CFLAGS="-I`${CYGPATH_W} $withval` $CLPLIB_CFLAGS"
     23581       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     23582       if test -z "$PKG_CONFIG" ; then
     23583         GLPK_CFLAGS_INSTALLED="$GLPK_CFLAGS"
     23584         CLPLIB_CFLAGS_INSTALLED="$GLPK_CFLAGS $CLPLIB_CFLAGS_INSTALLED"
     23585       fi
     23586     fi
     23587
     23588fi;
     23589fi
     23590
     23591if test $coin_has_glpk != skipping; then
     23592
     23593# Check whether --with-m4_tolower(Glpk)-datadir or --without-m4_tolower(Glpk)-datadir was given.
     23594if test "${with_glpk_datadir+set}" = set; then
     23595  withval="$with_glpk_datadir"
     23596  if test "$withval" = no ; then
     23597       coin_has_glpk=skipping
     23598     else
     23599       coin_has_glpk=yes
     23600       GLPK_DATA="$withval"
     23601       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     23602       if test -z "$PKG_CONFIG" ; then
     23603         GLPK_DATA_INSTALLED="$withval"
     23604       fi
     23605     fi
     23606
     23607fi;
     23608fi
     23609
     23610if test $coin_has_glpk = notGiven; then
     23611  if test -n "$PKG_CONFIG" ; then
     23612    # set search path for pkg-config
     23613    # need to export variable to be sure that the following pkg-config gets these values
     23614    coin_save_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
     23615    PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH:$COIN_PKG_CONFIG_PATH_UNINSTALLED"
     23616    export PKG_CONFIG_PATH
     23617
     23618    # let pkg-config do it's magic
     23619
     23620
     23621
     23622if test -n "$PKG_CONFIG" ; then
     23623  if $PKG_CONFIG --exists "coinglpk >= 4.39"; then
     23624    GLPK_VERSIONS="`$PKG_CONFIG --modversion "coinglpk >= 4.39" 2>/dev/null | tr '\n' ' '`"
     23625     cflags=`$PKG_CONFIG --cflags "coinglpk >= 4.39" 2>/dev/null`
     23626    # pkg-config cannot handle spaces, so CYGPATH_W cannot be put into .pc files
     23627        # thus, we modify the cflags extracted from pkg-config by putting CYGPATH_W behind -I's
     23628        # but only do this if is not trivial
     23629    if test "$CYGPATH_W" != "echo" ; then
     23630      # need to put into brackets since otherwise autoconf replaces the brackets in the sed command
     23631      cflags=`echo $cflags | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     23632    fi
     23633    GLPK_CFLAGS="$cflags"
     23634    GLPK_LIBS=`$PKG_CONFIG --libs "coinglpk >= 4.39" 2>/dev/null`
     23635    GLPK_DATA=`$PKG_CONFIG --variable=datadir "coinglpk >= 4.39" 2>/dev/null`
     23636     coin_has_glpk=yes
     23637        echo "$as_me:$LINENO: result: yes: $GLPK_VERSIONS" >&5
     23638echo "${ECHO_T}yes: $GLPK_VERSIONS" >&6
     23639
     23640        # adjust linker flags for (i)cl compiler
     23641        # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl)
     23642        if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ;
     23643        then
     23644          GLPK_LIBS=`echo " $GLPK_LIBS " | sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g'`
     23645        fi
     23646
     23647        # augment X_PCREQUIRES, X_CFLAGS, and X_LIBS for each build target X in ClpLib
     23648
     23649          CLPLIB_PCREQUIRES="coinglpk >= 4.39 $CLPLIB_PCREQUIRES"
     23650          CLPLIB_CFLAGS="$GLPK_CFLAGS $CLPLIB_CFLAGS"
     23651          CLPLIB_LIBS="$GLPK_LIBS $CLPLIB_LIBS"
     23652
     23653
     23654
     23655  else
     23656    GLPK_PKG_ERRORS=`$PKG_CONFIG $pkg_short_errors --errors-to-stdout --print-errors "coinglpk >= 4.39"`
     23657      coin_has_glpk=notGiven
     23658        echo "$as_me:$LINENO: result: not given: $GLPK_PKG_ERRORS" >&5
     23659echo "${ECHO_T}not given: $GLPK_PKG_ERRORS" >&6
     23660
     23661  fi
     23662else
     23663  { { echo "$as_me:$LINENO: error: \"Cannot check for existance of module Glpk without pkg-config\"" >&5
     23664echo "$as_me: error: \"Cannot check for existance of module Glpk without pkg-config\"" >&2;}
     23665   { (exit 1); exit 1; }; }
     23666fi
     23667
     23668
     23669
     23670
     23671    # reset PKG_CONFIG_PATH variable
     23672    PKG_CONFIG_PATH="$coin_save_PKG_CONFIG_PATH"
     23673    export PKG_CONFIG_PATH
     23674
     23675  else
     23676    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     23677echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     23678
     23679echo "$as_me:$LINENO: checking for COIN-OR package Glpk (fallback)" >&5
     23680echo $ECHO_N "checking for COIN-OR package Glpk (fallback)... $ECHO_C" >&6
     23681
     23682coin_has_glpk=notGiven
     23683GLPK_LIBS=
     23684GLPK_LIBS_INSTALLED=
     23685GLPK_CFLAGS=
     23686GLPK_CFLAGS_INSTALLED=
     23687GLPK_DATA=
     23688GLPK_DATA_INSTALLED=
     23689
     23690# initial list of dependencies is "coinglpk >= 4.39", but we need to filter out version number specifications (= x, <= x, >= x)
     23691projtoprocess="coinglpk "
     23692
     23693# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     23694# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     23695# the latter we also do with .pc files corresponding to the installed projects, which will be needed to setup Makefiles for examples
     23696# also, we setup the DATA variable
     23697allproj=""
     23698allpcfiles=""
     23699allpcifiles=""
     23700while test "x$projtoprocess" != x ; do
     23701
     23702  for proj in $projtoprocess ; do
     23703    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     23704    pcfile=""
     23705    save_IFS="$IFS"
     23706    IFS=":"
     23707    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     23708      # the base directory configure should have setup coin_subdirs.txt in a way that it does not contain projects that should be skipped, so we do not need to test this here again
     23709      if test -r "$dir/${proj}-uninstalled.pc" ; then
     23710        pcfile="$dir/$proj-uninstalled.pc"
     23711        if test -r "$dir/${proj}.pc" ; then
     23712          pcifile="$dir/${proj}.pc"
     23713        else
     23714          { echo "$as_me:$LINENO: WARNING: Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples." >&5
     23715echo "$as_me: WARNING: Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples." >&2;}
     23716          pcifile=
     23717        fi
     23718        break
     23719      fi
     23720    done
     23721    IFS="$save_IFS"
     23722
     23723    if test "x$pcfile" != x ; then
     23724      # read dependencies from $pcfile and filter it
     23725      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     23726
     23727      # add projrequires to the front of the list of projects that have to be processed next
     23728      # at the same time, remove $proj from this list
     23729      projtoprocess=${projtoprocess/$proj/$projrequires}
     23730
     23731      # read DATA from $pcfile, if _DATA is still empty
     23732      if test "x$GLPK_DATA" = x ; then
     23733        projdatadir=
     23734        pcfilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcfile`
     23735        eval `sh -c "$pcfilemod"`
     23736        GLPK_DATA="$projdatadir"
     23737      fi
     23738
     23739      allproj="$allproj $proj"
     23740      allpcfiles="$pcfile:$allpcfiles"
     23741
     23742    else
     23743      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     23744echo "${ECHO_T}no, dependency $proj not available" >&6
     23745      allproj=fail
     23746      break 2
     23747    fi
     23748
     23749    if test "x$pcifile" != x ; then
     23750      allpcifiles="$pcifile:$allpcifiles"
     23751
     23752      # read DATA_INSTALLED from $pcifile, if _DATA_INSTALLED is still empty
     23753      if test "x$GLPK_DATA_INSTALLED" = x ; then
     23754        projdatadir=
     23755        pcifilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcifile`
     23756        eval `sh -c "$pcifilemod"`
     23757        if test "${CYGPATH_W}" != "echo"; then
     23758          projdatadir="\`\$(CYGPATH_W) ${projdatadir} | sed -e 's/\\\\\\\\/\\\\\\\\\\\\\\\\/g'\`"
     23759        fi
     23760        GLPK_DATA_INSTALLED="$projdatadir"
     23761      fi
     23762
     23763    fi
     23764
     23765    break
     23766  done
     23767
     23768  # remove spaces on begin of $projtoprocess
     23769  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     23770
     23771done
     23772
     23773if test "$allproj" != fail ; then
     23774
     23775  # now go through the list of .pc files and assemble compiler and linker flags
     23776  # important is here to obey the reverse order that has been setup before,
     23777  # since then libraries that are required by several others should be after these other libraries
     23778  pcfilesprocessed=""
     23779
     23780  save_IFS="$IFS"
     23781  IFS=":"
     23782  for pcfile in $allpcfiles ; do
     23783
     23784    # if $pcfile has been processed already, skip this round
     23785    if test "x$pcfilesprocessed" != x ; then
     23786      for pcfiledone in $pcfilesprocessed ; do
     23787        if test "$pcfiledone" = "$pcfile" ; then
     23788          continue 2
     23789        fi
     23790      done
     23791    fi
     23792
     23793    # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags:
     23794    #   replace "Libs:" by "echo projlibs="
     23795    #   replace "Cflags:" by "echo projcflags="
     23796    #   remove every line starting with <some word>:
     23797    pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`
     23798
     23799    # set projcflags and projlibs variables by running $pcfilemod
     23800    projcflags=
     23801    projlibs=
     23802    eval `sh -c "$pcfilemod"`
     23803
     23804    # add CYGPATH_W cludge into include flags and set CFLAGS variable
     23805    if test "${CYGPATH_W}" != "echo"; then
     23806      projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     23807    fi
     23808    GLPK_CFLAGS="$projcflags $GLPK_CFLAGS"
     23809
     23810    # set LIBS variable
     23811    GLPK_LIBS="$projlibs $GLPK_LIBS"
     23812
     23813    # remember that we have processed $pcfile
     23814    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     23815
     23816  done
     23817  IFS="$save_IFS"
     23818
     23819
     23820  # now go through the list of .pc files for installed projects and assemble compiler and linker flags
     23821  # important is here again to obey the reverse order that has been setup before,
     23822  # since then libraries that are required by several others should be after these other libraries
     23823  pcfilesprocessed=""
     23824
     23825  save_IFS="$IFS"
     23826  IFS=":"
     23827  for pcfile in $allpcifiles ; do
     23828
     23829    # if $pcfile has been processed already, skip this round
     23830    if test "x$pcfilesprocessed" != x ; then
     23831      for pcfiledone in $pcfilesprocessed ; do
     23832        if test "$pcfiledone" = "$pcfile" ; then
     23833          continue 2
     23834        fi
     23835      done
     23836    fi
     23837
     23838    # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags:
     23839    #   replace "Libs:" by "echo projlibs="
     23840    #   replace "Cflags:" by "echo projcflags="
     23841    #   remove every line starting with <some word>:
     23842    pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`
     23843
     23844    # set projcflags and projlibs variables by running $pcfilemod
     23845    projcflags=
     23846    projlibs=
     23847    eval `sh -c "$pcfilemod"`
     23848
     23849    # add CYGPATH_W cludge into include flags and set CFLAGS variable
     23850    if test "${CYGPATH_W}" != "echo"; then
     23851      projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     23852    fi
     23853    GLPK_CFLAGS_INSTALLED="$projcflags $GLPK_CFLAGS_INSTALLED"
     23854
     23855    # set LIBS variable
     23856    GLPK_LIBS_INSTALLED="$projlibs $GLPK_LIBS_INSTALLED"
     23857
     23858    # remember that we have processed $pcfile
     23859    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     23860
     23861  done
     23862  IFS="$save_IFS"
     23863
     23864
     23865  # finish up
     23866  coin_has_glpk=yes
     23867  echo "$as_me:$LINENO: result: yes" >&5
     23868echo "${ECHO_T}yes" >&6
     23869
     23870cat >>confdefs.h <<\_ACEOF
     23871#define COIN_HAS_GLPK 1
     23872_ACEOF
     23873
     23874
     23875  # adjust linker flags for (i)cl compiler
     23876  # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl),
     23877  # for the LIBS_INSTALLED, we replace everything of the form "/somepath/" by "`$(CYGPATH_W) /somepath/`",
     23878  #    everything of the form "-Lpath" by "/libpath:`$(CYGPATH_W) path`, and
     23879  #    everything of the form "-lname" by "libname.lib"
     23880  if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ;
     23881  then
     23882    GLPK_LIBS=`echo " $GLPK_LIBS " | sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g'`
     23883    GLPK_LIBS_INSTALLED=`echo " $GLPK_LIBS_INSTALLED" | sed -e 's/ \(\/[^ ]*\/\)/ \`$(CYGPATH_W) \1\`/g' -e 's/ -L\([^ ]*\)/ \/libpath:\`$(CYGPATH_W) \1\`/g' -e 's/ -l\([^ ]*\)/ lib\1.lib/g'`
     23884  fi
     23885
     23886
     23887    CLPLIB_PCREQUIRES="coinglpk >= 4.39 $CLPLIB_PCREQUIRES"
     23888    CLPLIB_CFLAGS="$GLPK_CFLAGS $CLPLIB_CFLAGS"
     23889    CLPLIB_LIBS="$GLPK_LIBS $CLPLIB_LIBS"
     23890    CLPLIB_CFLAGS_INSTALLED="$GLPK_CFLAGS_INSTALLED $CLPLIB_CFLAGS_INSTALLED"
     23891    CLPLIB_LIBS_INSTALLED="$GLPK_LIBS_INSTALLED $CLPLIB_LIBS_INSTALLED"
     23892
     23893
     23894fi
     23895
     23896
     23897
     23898if test $coin_has_glpk != notGiven &&
     23899                test $coin_has_glpk != skipping; then
     23900  COIN_HAS_GLPK_TRUE=
     23901  COIN_HAS_GLPK_FALSE='#'
     23902else
     23903  COIN_HAS_GLPK_TRUE='#'
     23904  COIN_HAS_GLPK_FALSE=
     23905fi
     23906
     23907
     23908
     23909  fi
     23910
     23911else
     23912  echo "$as_me:$LINENO: result: $coin_has_glpk" >&5
     23913echo "${ECHO_T}$coin_has_glpk" >&6
     23914fi
     23915
     23916if test $coin_has_glpk != skipping &&
     23917   test $coin_has_glpk != notGiven ; then
     23918
     23919cat >>confdefs.h <<\_ACEOF
     23920#define COIN_HAS_GLPK 1
     23921_ACEOF
     23922
     23923
     23924  # Check whether --enable-interpackage-dependencies or --disable-interpackage-dependencies was given.
     23925if test "${enable_interpackage_dependencies+set}" = set; then
     23926  enableval="$enable_interpackage_dependencies"
     23927
     23928else
     23929  enable_interpackage_dependencies=yes
     23930fi;
     23931
     23932  if test $enable_interpackage_dependencies = yes ; then
     23933     # construct dependencies variables from LIBS variables
     23934     # we add an extra space in LIBS so we can substitute out everything starting with " -"
     23935     # remove everything of the form -framework xxx as used on Mac and mklxxx as used on Windows
     23936     # then remove everything of the form -xxx
     23937     # also remove everything of the form `xxx`yyy (may have been added for cygwin/cl)
     23938     GLPK_DEPENDENCIES=`echo " $GLPK_LIBS" | sed -e 's/ mkl[^ ]*//g' -e 's/ -framework  *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g'`
     23939
     23940       CLPLIB_DEPENDENCIES=`echo " $CLPLIB_LIBS " | sed -e 's/ mkl[^ ]*//g' -e 's/ -framework  *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g'`
     23941
     23942  fi
     23943
     23944  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     23945    if test -n "$GLPK_CFLAGS" ; then
     23946      { echo "$as_me:$LINENO: Glpk CFLAGS are $GLPK_CFLAGS" >&5
     23947echo "$as_me: Glpk CFLAGS are $GLPK_CFLAGS" >&6;}
     23948    fi
     23949    if test -n "$GLPK_LIBS" ; then
     23950      { echo "$as_me:$LINENO: Glpk LIBS   are $GLPK_LIBS" >&5
     23951echo "$as_me: Glpk LIBS   are $GLPK_LIBS" >&6;}
     23952    fi
     23953    if test -n "$GLPK_DEPENDENCIES" ; then
     23954      { echo "$as_me:$LINENO: Glpk DEPENDENCIES are $GLPK_DEPENDENCIES" >&5
     23955echo "$as_me: Glpk DEPENDENCIES are $GLPK_DEPENDENCIES" >&6;}
     23956    fi
     23957    if test -n "$GLPK_DATA" ; then
     23958      { echo "$as_me:$LINENO: Glpk DATA   is  $GLPK_DATA" >&5
     23959echo "$as_me: Glpk DATA   is  $GLPK_DATA" >&6;}
     23960    fi
     23961    if test -n "$GLPK_CFLAGS" ; then
     23962      { echo "$as_me:$LINENO: Glpk CFLAGS are $GLPK_CFLAGS" >&5
     23963echo "$as_me: Glpk CFLAGS are $GLPK_CFLAGS" >&6;}
     23964    fi
     23965
     23966      { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
     23967echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
     23968      { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
     23969echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
     23970      { echo "$as_me:$LINENO: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&5
     23971echo "$as_me: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&6;}
     23972
     23973  fi
     23974fi
     23975
     23976# Define the Makefile conditional
     23977
     23978
     23979if test $coin_has_glpk != notGiven &&
     23980                test $coin_has_glpk != skipping; then
     23981  COIN_HAS_GLPK_TRUE=
     23982  COIN_HAS_GLPK_FALSE='#'
     23983else
     23984  COIN_HAS_GLPK_TRUE='#'
     23985  COIN_HAS_GLPK_FALSE=
     23986fi
     23987
     23988
     23989
     23990  if test $coin_has_glpk = yes ; then
     23991    { echo "$as_me:$LINENO: using AMD from GLPK package" >&5
     23992echo "$as_me: using AMD from GLPK package" >&6;}
     23993
     23994cat >>confdefs.h <<\_ACEOF
     23995#define COIN_HAS_AMD 1
     23996_ACEOF
     23997
     23998  fi
     23999else
     24000  # for configure
     24001
     24002
     24003if test 0 = 1; then
     24004  COIN_HAS_GLPK_TRUE=
     24005  COIN_HAS_GLPK_FALSE='#'
     24006else
     24007  COIN_HAS_GLPK_TRUE='#'
     24008  COIN_HAS_GLPK_FALSE=
     24009fi
     24010
     24011fi
     24012
     24013# MUMPS
     24014
     24015echo "$as_me:$LINENO: checking for COIN-OR package Mumps" >&5
     24016echo $ECHO_N "checking for COIN-OR package Mumps... $ECHO_C" >&6
     24017
     24018coin_has_mumps=notGiven
     24019
     24020# check if user wants to skip package in any case
     24021if test x"$COIN_SKIP_PROJECTS" != x; then
     24022  for dir in $COIN_SKIP_PROJECTS; do
     24023    if test $dir = "Mumps"; then
     24024      coin_has_mumps=skipping
     24025    fi
     24026  done
     24027fi
     24028
     24029MUMPS_LIBS=
     24030MUMPS_CFLAGS=
     24031MUMPS_DATA=
     24032
     24033
     24034
     24035
     24036
     24037
     24038
     24039
     24040
     24041
     24042
     24043
     24044
     24045
     24046
     24047
     24048
     24049#check if user provided LIBS, CFLAGS, or DATA for package or disables use of package
     24050if test $coin_has_mumps != skipping; then
     24051
     24052# Check whether --with-m4_tolower(Mumps)-lib or --without-m4_tolower(Mumps)-lib was given.
     24053if test "${with_mumps_lib+set}" = set; then
     24054  withval="$with_mumps_lib"
     24055  if test "$withval" = no ; then
     24056       coin_has_mumps=skipping
     24057     else
     24058       coin_has_mumps=yes
     24059       MUMPS_LIBS="$withval"
     24060
     24061         CLPLIB_PCLIBS="$withval $CLPLIB_PCLIBS"
     24062         CLPLIB_LIBS="$withval $CLPLIB_LIBS"
     24063
     24064       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     24065       if test -z "$PKG_CONFIG" ; then
     24066         MUMPS_LIBS_INSTALLED="$withval"
     24067         CLPLIB_LIBS_INSTALLED="$withval $CLPLIB_LIBS_INSTALLED"
     24068       fi
     24069     fi
     24070
     24071fi;
     24072fi
     24073
     24074if test $coin_has_mumps != skipping; then
     24075
     24076# Check whether --with-m4_tolower(Mumps)-incdir or --without-m4_tolower(Mumps)-incdir was given.
     24077if test "${with_mumps_incdir+set}" = set; then
     24078  withval="$with_mumps_incdir"
     24079  if test "$withval" = no ; then
     24080       coin_has_mumps=skipping
     24081     else
     24082       coin_has_mumps=yes
     24083       MUMPS_CFLAGS="-I`${CYGPATH_W} $withval`"
     24084       CLPLIB_CFLAGS="-I`${CYGPATH_W} $withval` $CLPLIB_CFLAGS"
     24085       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     24086       if test -z "$PKG_CONFIG" ; then
     24087         MUMPS_CFLAGS_INSTALLED="$MUMPS_CFLAGS"
     24088         CLPLIB_CFLAGS_INSTALLED="$MUMPS_CFLAGS $CLPLIB_CFLAGS_INSTALLED"
     24089       fi
     24090     fi
     24091
     24092fi;
     24093fi
     24094
     24095if test $coin_has_mumps != skipping; then
     24096
     24097# Check whether --with-m4_tolower(Mumps)-datadir or --without-m4_tolower(Mumps)-datadir was given.
     24098if test "${with_mumps_datadir+set}" = set; then
     24099  withval="$with_mumps_datadir"
     24100  if test "$withval" = no ; then
     24101       coin_has_mumps=skipping
     24102     else
     24103       coin_has_mumps=yes
     24104       MUMPS_DATA="$withval"
     24105       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     24106       if test -z "$PKG_CONFIG" ; then
     24107         MUMPS_DATA_INSTALLED="$withval"
     24108       fi
     24109     fi
     24110
     24111fi;
     24112fi
     24113
     24114if test $coin_has_mumps = notGiven; then
     24115  if test -n "$PKG_CONFIG" ; then
     24116    # set search path for pkg-config
     24117    # need to export variable to be sure that the following pkg-config gets these values
     24118    coin_save_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
     24119    PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH:$COIN_PKG_CONFIG_PATH_UNINSTALLED"
     24120    export PKG_CONFIG_PATH
     24121
     24122    # let pkg-config do it's magic
     24123
     24124
     24125
     24126if test -n "$PKG_CONFIG" ; then
     24127  if $PKG_CONFIG --exists "coinmumps"; then
     24128    MUMPS_VERSIONS="`$PKG_CONFIG --modversion "coinmumps" 2>/dev/null | tr '\n' ' '`"
     24129     cflags=`$PKG_CONFIG --cflags "coinmumps" 2>/dev/null`
     24130    # pkg-config cannot handle spaces, so CYGPATH_W cannot be put into .pc files
     24131        # thus, we modify the cflags extracted from pkg-config by putting CYGPATH_W behind -I's
     24132        # but only do this if is not trivial
     24133    if test "$CYGPATH_W" != "echo" ; then
     24134      # need to put into brackets since otherwise autoconf replaces the brackets in the sed command
     24135      cflags=`echo $cflags | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     24136    fi
     24137    MUMPS_CFLAGS="$cflags"
     24138    MUMPS_LIBS=`$PKG_CONFIG --libs "coinmumps" 2>/dev/null`
     24139    MUMPS_DATA=`$PKG_CONFIG --variable=datadir "coinmumps" 2>/dev/null`
     24140     coin_has_mumps=yes
     24141        echo "$as_me:$LINENO: result: yes: $MUMPS_VERSIONS" >&5
     24142echo "${ECHO_T}yes: $MUMPS_VERSIONS" >&6
     24143
     24144        # adjust linker flags for (i)cl compiler
     24145        # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl)
     24146        if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ;
     24147        then
     24148          MUMPS_LIBS=`echo " $MUMPS_LIBS " | sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g'`
     24149        fi
     24150
     24151        # augment X_PCREQUIRES, X_CFLAGS, and X_LIBS for each build target X in ClpLib
     24152
     24153          CLPLIB_PCREQUIRES="coinmumps $CLPLIB_PCREQUIRES"
     24154          CLPLIB_CFLAGS="$MUMPS_CFLAGS $CLPLIB_CFLAGS"
     24155          CLPLIB_LIBS="$MUMPS_LIBS $CLPLIB_LIBS"
     24156
     24157
     24158
     24159  else
     24160    MUMPS_PKG_ERRORS=`$PKG_CONFIG $pkg_short_errors --errors-to-stdout --print-errors "coinmumps"`
     24161      coin_has_mumps=notGiven
     24162        echo "$as_me:$LINENO: result: not given: $MUMPS_PKG_ERRORS" >&5
     24163echo "${ECHO_T}not given: $MUMPS_PKG_ERRORS" >&6
     24164
     24165  fi
     24166else
     24167  { { echo "$as_me:$LINENO: error: \"Cannot check for existance of module Mumps without pkg-config\"" >&5
     24168echo "$as_me: error: \"Cannot check for existance of module Mumps without pkg-config\"" >&2;}
     24169   { (exit 1); exit 1; }; }
     24170fi
     24171
     24172
     24173
     24174
     24175    # reset PKG_CONFIG_PATH variable
     24176    PKG_CONFIG_PATH="$coin_save_PKG_CONFIG_PATH"
     24177    export PKG_CONFIG_PATH
     24178
     24179  else
     24180    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     24181echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     24182
     24183echo "$as_me:$LINENO: checking for COIN-OR package Mumps (fallback)" >&5
     24184echo $ECHO_N "checking for COIN-OR package Mumps (fallback)... $ECHO_C" >&6
     24185
     24186coin_has_mumps=notGiven
     24187MUMPS_LIBS=
     24188MUMPS_LIBS_INSTALLED=
     24189MUMPS_CFLAGS=
     24190MUMPS_CFLAGS_INSTALLED=
     24191MUMPS_DATA=
     24192MUMPS_DATA_INSTALLED=
     24193
     24194# initial list of dependencies is "coinmumps", but we need to filter out version number specifications (= x, <= x, >= x)
     24195projtoprocess="coinmumps"
     24196
     24197# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     24198# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     24199# the latter we also do with .pc files corresponding to the installed projects, which will be needed to setup Makefiles for examples
     24200# also, we setup the DATA variable
     24201allproj=""
     24202allpcfiles=""
     24203allpcifiles=""
     24204while test "x$projtoprocess" != x ; do
     24205
     24206  for proj in $projtoprocess ; do
     24207    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     24208    pcfile=""
     24209    save_IFS="$IFS"
     24210    IFS=":"
     24211    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     24212      # the base directory configure should have setup coin_subdirs.txt in a way that it does not contain projects that should be skipped, so we do not need to test this here again
     24213      if test -r "$dir/${proj}-uninstalled.pc" ; then
     24214        pcfile="$dir/$proj-uninstalled.pc"
     24215        if test -r "$dir/${proj}.pc" ; then
     24216          pcifile="$dir/${proj}.pc"
     24217        else
     24218          { echo "$as_me:$LINENO: WARNING: Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples." >&5
     24219echo "$as_me: WARNING: Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples." >&2;}
     24220          pcifile=
     24221        fi
     24222        break
     24223      fi
     24224    done
     24225    IFS="$save_IFS"
     24226
     24227    if test "x$pcfile" != x ; then
     24228      # read dependencies from $pcfile and filter it
     24229      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     24230
     24231      # add projrequires to the front of the list of projects that have to be processed next
     24232      # at the same time, remove $proj from this list
     24233      projtoprocess=${projtoprocess/$proj/$projrequires}
     24234
     24235      # read DATA from $pcfile, if _DATA is still empty
     24236      if test "x$MUMPS_DATA" = x ; then
     24237        projdatadir=
     24238        pcfilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcfile`
     24239        eval `sh -c "$pcfilemod"`
     24240        MUMPS_DATA="$projdatadir"
     24241      fi
     24242
     24243      allproj="$allproj $proj"
     24244      allpcfiles="$pcfile:$allpcfiles"
     24245
     24246    else
     24247      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     24248echo "${ECHO_T}no, dependency $proj not available" >&6
     24249      allproj=fail
     24250      break 2
     24251    fi
     24252
     24253    if test "x$pcifile" != x ; then
     24254      allpcifiles="$pcifile:$allpcifiles"
     24255
     24256      # read DATA_INSTALLED from $pcifile, if _DATA_INSTALLED is still empty
     24257      if test "x$MUMPS_DATA_INSTALLED" = x ; then
     24258        projdatadir=
     24259        pcifilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcifile`
     24260        eval `sh -c "$pcifilemod"`
     24261        if test "${CYGPATH_W}" != "echo"; then
     24262          projdatadir="\`\$(CYGPATH_W) ${projdatadir} | sed -e 's/\\\\\\\\/\\\\\\\\\\\\\\\\/g'\`"
     24263        fi
     24264        MUMPS_DATA_INSTALLED="$projdatadir"
     24265      fi
     24266
     24267    fi
     24268
     24269    break
     24270  done
     24271
     24272  # remove spaces on begin of $projtoprocess
     24273  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     24274
     24275done
     24276
     24277if test "$allproj" != fail ; then
     24278
     24279  # now go through the list of .pc files and assemble compiler and linker flags
     24280  # important is here to obey the reverse order that has been setup before,
     24281  # since then libraries that are required by several others should be after these other libraries
     24282  pcfilesprocessed=""
     24283
     24284  save_IFS="$IFS"
     24285  IFS=":"
     24286  for pcfile in $allpcfiles ; do
     24287
     24288    # if $pcfile has been processed already, skip this round
     24289    if test "x$pcfilesprocessed" != x ; then
     24290      for pcfiledone in $pcfilesprocessed ; do
     24291        if test "$pcfiledone" = "$pcfile" ; then
     24292          continue 2
     24293        fi
     24294      done
     24295    fi
     24296
     24297    # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags:
     24298    #   replace "Libs:" by "echo projlibs="
     24299    #   replace "Cflags:" by "echo projcflags="
     24300    #   remove every line starting with <some word>:
     24301    pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`
     24302
     24303    # set projcflags and projlibs variables by running $pcfilemod
     24304    projcflags=
     24305    projlibs=
     24306    eval `sh -c "$pcfilemod"`
     24307
     24308    # add CYGPATH_W cludge into include flags and set CFLAGS variable
     24309    if test "${CYGPATH_W}" != "echo"; then
     24310      projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     24311    fi
     24312    MUMPS_CFLAGS="$projcflags $MUMPS_CFLAGS"
     24313
     24314    # set LIBS variable
     24315    MUMPS_LIBS="$projlibs $MUMPS_LIBS"
     24316
     24317    # remember that we have processed $pcfile
     24318    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     24319
     24320  done
     24321  IFS="$save_IFS"
     24322
     24323
     24324  # now go through the list of .pc files for installed projects and assemble compiler and linker flags
     24325  # important is here again to obey the reverse order that has been setup before,
     24326  # since then libraries that are required by several others should be after these other libraries
     24327  pcfilesprocessed=""
     24328
     24329  save_IFS="$IFS"
     24330  IFS=":"
     24331  for pcfile in $allpcifiles ; do
     24332
     24333    # if $pcfile has been processed already, skip this round
     24334    if test "x$pcfilesprocessed" != x ; then
     24335      for pcfiledone in $pcfilesprocessed ; do
     24336        if test "$pcfiledone" = "$pcfile" ; then
     24337          continue 2
     24338        fi
     24339      done
     24340    fi
     24341
     24342    # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags:
     24343    #   replace "Libs:" by "echo projlibs="
     24344    #   replace "Cflags:" by "echo projcflags="
     24345    #   remove every line starting with <some word>:
     24346    pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`
     24347
     24348    # set projcflags and projlibs variables by running $pcfilemod
     24349    projcflags=
     24350    projlibs=
     24351    eval `sh -c "$pcfilemod"`
     24352
     24353    # add CYGPATH_W cludge into include flags and set CFLAGS variable
     24354    if test "${CYGPATH_W}" != "echo"; then
     24355      projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     24356    fi
     24357    MUMPS_CFLAGS_INSTALLED="$projcflags $MUMPS_CFLAGS_INSTALLED"
     24358
     24359    # set LIBS variable
     24360    MUMPS_LIBS_INSTALLED="$projlibs $MUMPS_LIBS_INSTALLED"
     24361
     24362    # remember that we have processed $pcfile
     24363    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     24364
     24365  done
     24366  IFS="$save_IFS"
     24367
     24368
     24369  # finish up
     24370  coin_has_mumps=yes
     24371  echo "$as_me:$LINENO: result: yes" >&5
     24372echo "${ECHO_T}yes" >&6
     24373
     24374cat >>confdefs.h <<\_ACEOF
     24375#define COIN_HAS_MUMPS 1
     24376_ACEOF
     24377
     24378
     24379  # adjust linker flags for (i)cl compiler
     24380  # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl),
     24381  # for the LIBS_INSTALLED, we replace everything of the form "/somepath/" by "`$(CYGPATH_W) /somepath/`",
     24382  #    everything of the form "-Lpath" by "/libpath:`$(CYGPATH_W) path`, and
     24383  #    everything of the form "-lname" by "libname.lib"
     24384  if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ;
     24385  then
     24386    MUMPS_LIBS=`echo " $MUMPS_LIBS " | sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g'`
     24387    MUMPS_LIBS_INSTALLED=`echo " $MUMPS_LIBS_INSTALLED" | sed -e 's/ \(\/[^ ]*\/\)/ \`$(CYGPATH_W) \1\`/g' -e 's/ -L\([^ ]*\)/ \/libpath:\`$(CYGPATH_W) \1\`/g' -e 's/ -l\([^ ]*\)/ lib\1.lib/g'`
     24388  fi
     24389
     24390
     24391    CLPLIB_PCREQUIRES="coinmumps $CLPLIB_PCREQUIRES"
     24392    CLPLIB_CFLAGS="$MUMPS_CFLAGS $CLPLIB_CFLAGS"
     24393    CLPLIB_LIBS="$MUMPS_LIBS $CLPLIB_LIBS"
     24394    CLPLIB_CFLAGS_INSTALLED="$MUMPS_CFLAGS_INSTALLED $CLPLIB_CFLAGS_INSTALLED"
     24395    CLPLIB_LIBS_INSTALLED="$MUMPS_LIBS_INSTALLED $CLPLIB_LIBS_INSTALLED"
     24396
     24397
     24398fi
     24399
     24400
     24401
     24402if test $coin_has_mumps != notGiven &&
     24403                test $coin_has_mumps != skipping; then
     24404  COIN_HAS_MUMPS_TRUE=
     24405  COIN_HAS_MUMPS_FALSE='#'
     24406else
     24407  COIN_HAS_MUMPS_TRUE='#'
     24408  COIN_HAS_MUMPS_FALSE=
     24409fi
     24410
     24411
     24412
     24413  fi
     24414
     24415else
     24416  echo "$as_me:$LINENO: result: $coin_has_mumps" >&5
     24417echo "${ECHO_T}$coin_has_mumps" >&6
     24418fi
     24419
     24420if test $coin_has_mumps != skipping &&
     24421   test $coin_has_mumps != notGiven ; then
     24422
     24423cat >>confdefs.h <<\_ACEOF
     24424#define COIN_HAS_MUMPS 1
     24425_ACEOF
     24426
     24427
     24428  # Check whether --enable-interpackage-dependencies or --disable-interpackage-dependencies was given.
     24429if test "${enable_interpackage_dependencies+set}" = set; then
     24430  enableval="$enable_interpackage_dependencies"
     24431
     24432else
     24433  enable_interpackage_dependencies=yes
     24434fi;
     24435
     24436  if test $enable_interpackage_dependencies = yes ; then
     24437     # construct dependencies variables from LIBS variables
     24438     # we add an extra space in LIBS so we can substitute out everything starting with " -"
     24439     # remove everything of the form -framework xxx as used on Mac and mklxxx as used on Windows
     24440     # then remove everything of the form -xxx
     24441     # also remove everything of the form `xxx`yyy (may have been added for cygwin/cl)
     24442     MUMPS_DEPENDENCIES=`echo " $MUMPS_LIBS" | sed -e 's/ mkl[^ ]*//g' -e 's/ -framework  *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g'`
     24443
     24444       CLPLIB_DEPENDENCIES=`echo " $CLPLIB_LIBS " | sed -e 's/ mkl[^ ]*//g' -e 's/ -framework  *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g'`
     24445
     24446  fi
     24447
     24448  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     24449    if test -n "$MUMPS_CFLAGS" ; then
     24450      { echo "$as_me:$LINENO: Mumps CFLAGS are $MUMPS_CFLAGS" >&5
     24451echo "$as_me: Mumps CFLAGS are $MUMPS_CFLAGS" >&6;}
     24452    fi
     24453    if test -n "$MUMPS_LIBS" ; then
     24454      { echo "$as_me:$LINENO: Mumps LIBS   are $MUMPS_LIBS" >&5
     24455echo "$as_me: Mumps LIBS   are $MUMPS_LIBS" >&6;}
     24456    fi
     24457    if test -n "$MUMPS_DEPENDENCIES" ; then
     24458      { echo "$as_me:$LINENO: Mumps DEPENDENCIES are $MUMPS_DEPENDENCIES" >&5
     24459echo "$as_me: Mumps DEPENDENCIES are $MUMPS_DEPENDENCIES" >&6;}
     24460    fi
     24461    if test -n "$MUMPS_DATA" ; then
     24462      { echo "$as_me:$LINENO: Mumps DATA   is  $MUMPS_DATA" >&5
     24463echo "$as_me: Mumps DATA   is  $MUMPS_DATA" >&6;}
     24464    fi
     24465    if test -n "$MUMPS_CFLAGS" ; then
     24466      { echo "$as_me:$LINENO: Mumps CFLAGS are $MUMPS_CFLAGS" >&5
     24467echo "$as_me: Mumps CFLAGS are $MUMPS_CFLAGS" >&6;}
     24468    fi
     24469
     24470      { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
     24471echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
     24472      { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
     24473echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
     24474      { echo "$as_me:$LINENO: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&5
     24475echo "$as_me: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&6;}
     24476
     24477  fi
     24478fi
     24479
     24480# Define the Makefile conditional
     24481
     24482
     24483if test $coin_has_mumps != notGiven &&
     24484                test $coin_has_mumps != skipping; then
     24485  COIN_HAS_MUMPS_TRUE=
     24486  COIN_HAS_MUMPS_FALSE='#'
     24487else
     24488  COIN_HAS_MUMPS_TRUE='#'
     24489  COIN_HAS_MUMPS_FALSE=
     24490fi
     24491
     24492
     24493
     24494
     24495# WSMP
     24496
     24497# Check whether --with-wsmp or --without-wsmp was given.
     24498if test "${with_wsmp+set}" = set; then
     24499  withval="$with_wsmp"
     24500  use_wsmp=$withval
     24501else
     24502  use_wsmp=no
     24503fi;
     24504
     24505if test "$use_wsmp" != "no"; then
     24506  # Check how to link against Fortran libraries from C
     24507  case $build in
     24508  *-cygwin* | *-mingw*)
     24509     if test "$enable_doscompile" = msvc ; then
     24510       coin_f77_comps="ifort fl32 compile_f2c"
     24511     else
     24512       coin_f77_comps="gfortran ifort g95 g77 fl32 compile_f2c"
     24513     fi ;;
     24514  *-*-solaris*)
     24515     coin_f77_comps="f95 f90 g95 f77 xlf_r fort77 gfortran g77 pgf90 pgf77 ifort ifc frt af77" ;;
     24516  *-linux-gnu*)
     24517     coin_f77_comps="gfortran ifort g95 fort77 f77 g77 pgf90 pgf77 ifc frt af77 xlf_r" ;;
     24518  *) coin_f77_comps="xlf_r fort77 gfortran ifort g95 f77 g77 pgf90 pgf77 ifc frt af77" ;;
     24519 esac
     24520
     24521
     24522
     24523
     24524
     24525ac_ext=f
     24526ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24527ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24528ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24529
     24530
     24531
     24532
     24533
     24534
     24535coin_has_f77=yes
     24536
     24537save_fflags="$FFLAGS"
     24538
     24539# We delete the cached value, since the test might not have been
     24540# performed with our choice of compilers earlier
     24541$as_unset ac_cv_prog_F77 || test "${ac_cv_prog_F77+set}" != set || { ac_cv_prog_F77=; export ac_cv_prog_F77; }
     24542
     24543# This is a real belt-and-suspenders approach. AC_COIN_FIND_F77 will use
     24544# coin_f77_comps to see if there's a program that matches one of the names.
     24545# If there's no such program, F77 = unavailable. If we match the name,
     24546# feed AC_PROG_F77 the same search list, just to be sure it's a functioning
     24547# compiler.
     24548# AC_MSG_NOTICE([Fortran compiler candidates: $coin_f77_comps])
     24549
     24550
     24551{ echo "$as_me:$LINENO: Trying to determine Fortran compiler name" >&5
     24552echo "$as_me: Trying to determine Fortran compiler name" >&6;}
     24553for ac_prog in $coin_f77_comps
     24554do
     24555  # Extract the first word of "$ac_prog", so it can be a program name with args.
     24556set dummy $ac_prog; ac_word=$2
     24557echo "$as_me:$LINENO: checking for $ac_word" >&5
     24558echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     24559if test "${ac_cv_prog_F77+set}" = set; then
     24560  echo $ECHO_N "(cached) $ECHO_C" >&6
     24561else
     24562  if test -n "$F77"; then
     24563  ac_cv_prog_F77="$F77" # Let the user override the test.
     24564else
     24565as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     24566for as_dir in $PATH
     24567do
     24568  IFS=$as_save_IFS
     24569  test -z "$as_dir" && as_dir=.
     24570  for ac_exec_ext in '' $ac_executable_extensions; do
     24571  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     24572    ac_cv_prog_F77="$ac_prog"
     24573    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     24574    break 2
     24575  fi
     24576done
     24577done
     24578
     24579fi
     24580fi
     24581F77=$ac_cv_prog_F77
     24582if test -n "$F77"; then
     24583  echo "$as_me:$LINENO: result: $F77" >&5
     24584echo "${ECHO_T}$F77" >&6
     24585else
     24586  echo "$as_me:$LINENO: result: no" >&5
     24587echo "${ECHO_T}no" >&6
     24588fi
     24589
     24590  test -n "$F77" && break
     24591done
     24592test -n "$F77" || F77="unavailable"
     24593
     24594
     24595if test "$F77" != "unavailable" ; then
     24596  ac_ext=f
     24597ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24598ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24599ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24600if test -n "$ac_tool_prefix"; then
     24601  for ac_prog in $coin_f77_comps
     24602  do
     24603    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     24604set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     24605echo "$as_me:$LINENO: checking for $ac_word" >&5
     24606echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     24607if test "${ac_cv_prog_F77+set}" = set; then
     24608  echo $ECHO_N "(cached) $ECHO_C" >&6
     24609else
     24610  if test -n "$F77"; then
     24611  ac_cv_prog_F77="$F77" # Let the user override the test.
     24612else
     24613as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     24614for as_dir in $PATH
     24615do
     24616  IFS=$as_save_IFS
     24617  test -z "$as_dir" && as_dir=.
     24618  for ac_exec_ext in '' $ac_executable_extensions; do
     24619  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     24620    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
     24621    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     24622    break 2
     24623  fi
     24624done
     24625done
     24626
     24627fi
     24628fi
     24629F77=$ac_cv_prog_F77
     24630if test -n "$F77"; then
     24631  echo "$as_me:$LINENO: result: $F77" >&5
     24632echo "${ECHO_T}$F77" >&6
     24633else
     24634  echo "$as_me:$LINENO: result: no" >&5
     24635echo "${ECHO_T}no" >&6
     24636fi
     24637
     24638    test -n "$F77" && break
     24639  done
     24640fi
     24641if test -z "$F77"; then
     24642  ac_ct_F77=$F77
     24643  for ac_prog in $coin_f77_comps
     24644do
     24645  # Extract the first word of "$ac_prog", so it can be a program name with args.
     24646set dummy $ac_prog; ac_word=$2
     24647echo "$as_me:$LINENO: checking for $ac_word" >&5
     24648echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
     24649if test "${ac_cv_prog_ac_ct_F77+set}" = set; then
     24650  echo $ECHO_N "(cached) $ECHO_C" >&6
     24651else
     24652  if test -n "$ac_ct_F77"; then
     24653  ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.
     24654else
     24655as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     24656for as_dir in $PATH
     24657do
     24658  IFS=$as_save_IFS
     24659  test -z "$as_dir" && as_dir=.
     24660  for ac_exec_ext in '' $ac_executable_extensions; do
     24661  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     24662    ac_cv_prog_ac_ct_F77="$ac_prog"
     24663    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     24664    break 2
     24665  fi
     24666done
     24667done
     24668
     24669fi
     24670fi
     24671ac_ct_F77=$ac_cv_prog_ac_ct_F77
     24672if test -n "$ac_ct_F77"; then
     24673  echo "$as_me:$LINENO: result: $ac_ct_F77" >&5
     24674echo "${ECHO_T}$ac_ct_F77" >&6
     24675else
     24676  echo "$as_me:$LINENO: result: no" >&5
     24677echo "${ECHO_T}no" >&6
     24678fi
     24679
     24680  test -n "$ac_ct_F77" && break
     24681done
     24682
     24683  F77=$ac_ct_F77
     24684fi
     24685
     24686
     24687# Provide some information about the compiler.
     24688echo "$as_me:24688:" \
     24689     "checking for Fortran 77 compiler version" >&5
     24690ac_compiler=`set X $ac_compile; echo $2`
     24691{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
     24692  (eval $ac_compiler --version </dev/null >&5) 2>&5
     24693  ac_status=$?
     24694  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24695  (exit $ac_status); }
     24696{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
     24697  (eval $ac_compiler -v </dev/null >&5) 2>&5
     24698  ac_status=$?
     24699  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24700  (exit $ac_status); }
     24701{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
     24702  (eval $ac_compiler -V </dev/null >&5) 2>&5
     24703  ac_status=$?
     24704  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24705  (exit $ac_status); }
     24706rm -f a.out
     24707
     24708# If we don't use `.F' as extension, the preprocessor is not run on the
     24709# input file.  (Note that this only needs to work for GNU compilers.)
     24710ac_save_ext=$ac_ext
     24711ac_ext=F
     24712echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5
     24713echo $ECHO_N "checking whether we are using the GNU Fortran 77 compiler... $ECHO_C" >&6
     24714if test "${ac_cv_f77_compiler_gnu+set}" = set; then
     24715  echo $ECHO_N "(cached) $ECHO_C" >&6
     24716else
     24717  cat >conftest.$ac_ext <<_ACEOF
     24718      program main
     24719#ifndef __GNUC__
     24720       choke me
     24721#endif
     24722
     24723      end
     24724_ACEOF
     24725rm -f conftest.$ac_objext
     24726if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     24727  (eval $ac_compile) 2>conftest.er1
     24728  ac_status=$?
     24729  grep -v '^ *+' conftest.er1 >conftest.err
     24730  rm -f conftest.er1
     24731  cat conftest.err >&5
     24732  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24733  (exit $ac_status); } &&
     24734         { ac_try='test -z "$ac_f77_werror_flag"
     24735                         || test ! -s conftest.err'
     24736  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24737  (eval $ac_try) 2>&5
     24738  ac_status=$?
     24739  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24740  (exit $ac_status); }; } &&
     24741         { ac_try='test -s conftest.$ac_objext'
     24742  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24743  (eval $ac_try) 2>&5
     24744  ac_status=$?
     24745  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24746  (exit $ac_status); }; }; then
     24747  ac_compiler_gnu=yes
     24748else
     24749  echo "$as_me: failed program was:" >&5
     24750sed 's/^/| /' conftest.$ac_ext >&5
     24751
     24752ac_compiler_gnu=no
     24753fi
     24754rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     24755ac_cv_f77_compiler_gnu=$ac_compiler_gnu
     24756
     24757fi
     24758echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5
     24759echo "${ECHO_T}$ac_cv_f77_compiler_gnu" >&6
     24760ac_ext=$ac_save_ext
     24761ac_test_FFLAGS=${FFLAGS+set}
     24762ac_save_FFLAGS=$FFLAGS
     24763FFLAGS=
     24764echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5
     24765echo $ECHO_N "checking whether $F77 accepts -g... $ECHO_C" >&6
     24766if test "${ac_cv_prog_f77_g+set}" = set; then
     24767  echo $ECHO_N "(cached) $ECHO_C" >&6
     24768else
     24769  FFLAGS=-g
     24770cat >conftest.$ac_ext <<_ACEOF
     24771      program main
     24772
     24773      end
     24774_ACEOF
     24775rm -f conftest.$ac_objext
     24776if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     24777  (eval $ac_compile) 2>conftest.er1
     24778  ac_status=$?
     24779  grep -v '^ *+' conftest.er1 >conftest.err
     24780  rm -f conftest.er1
     24781  cat conftest.err >&5
     24782  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24783  (exit $ac_status); } &&
     24784         { ac_try='test -z "$ac_f77_werror_flag"
     24785                         || test ! -s conftest.err'
     24786  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24787  (eval $ac_try) 2>&5
     24788  ac_status=$?
     24789  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24790  (exit $ac_status); }; } &&
     24791         { ac_try='test -s conftest.$ac_objext'
     24792  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24793  (eval $ac_try) 2>&5
     24794  ac_status=$?
     24795  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24796  (exit $ac_status); }; }; then
     24797  ac_cv_prog_f77_g=yes
     24798else
     24799  echo "$as_me: failed program was:" >&5
     24800sed 's/^/| /' conftest.$ac_ext >&5
     24801
     24802ac_cv_prog_f77_g=no
     24803fi
     24804rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     24805
     24806fi
     24807echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5
     24808echo "${ECHO_T}$ac_cv_prog_f77_g" >&6
     24809if test "$ac_test_FFLAGS" = set; then
     24810  FFLAGS=$ac_save_FFLAGS
     24811elif test $ac_cv_prog_f77_g = yes; then
     24812  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
     24813    FFLAGS="-g -O2"
     24814  else
     24815    FFLAGS="-g"
     24816  fi
     24817else
     24818  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
     24819    FFLAGS="-O2"
     24820  else
     24821    FFLAGS=
     24822  fi
     24823fi
     24824
     24825G77=`test $ac_compiler_gnu = yes && echo yes`
     24826ac_ext=f
     24827ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24828ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24829ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24830
     24831else
     24832  { echo "$as_me:$LINENO: WARNING: Failed to find a Fortran compiler!" >&5
     24833echo "$as_me: WARNING: Failed to find a Fortran compiler!" >&2;}
     24834fi
     24835
     24836FFLAGS="$save_fflags"
     24837
     24838# Check if a project specific FFLAGS variable has been set
     24839if test x$COIN_PRJCT != x; then
     24840  eval coin_tmp=\${${COIN_PRJCT}_FFLAGS+set}
     24841  if test x$coin_tmp = xset; then
     24842    eval FFLAGS=\${${COIN_PRJCT}_FFLAGS}
     24843  fi
     24844fi
     24845
     24846if test "$F77" != "unavailable" && test x"$FFLAGS" = x ; then
     24847
     24848  coin_add_fflags=
     24849  coin_opt_fflags=
     24850  coin_dbg_fflags=
     24851  coin_warn_fflags=
     24852
     24853  if test "$G77" = "yes"; then
     24854    coin_opt_fflags="-O3"
     24855    coin_add_fflags="-pipe"
     24856    coin_dbg_fflags="-g"
     24857    case $enable_doscompile in
     24858      mingw)
     24859        FFLAGS="-mno-cygwin"
     24860        cat >conftest.$ac_ext <<_ACEOF
     24861      program main
     24862      write(*,*) 'Hello world'
     24863      end
     24864_ACEOF
     24865rm -f conftest.$ac_objext conftest$ac_exeext
     24866if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     24867  (eval $ac_link) 2>conftest.er1
     24868  ac_status=$?
     24869  grep -v '^ *+' conftest.er1 >conftest.err
     24870  rm -f conftest.er1
     24871  cat conftest.err >&5
     24872  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24873  (exit $ac_status); } &&
     24874         { ac_try='test -z "$ac_f77_werror_flag"
     24875                         || test ! -s conftest.err'
     24876  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24877  (eval $ac_try) 2>&5
     24878  ac_status=$?
     24879  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24880  (exit $ac_status); }; } &&
     24881         { ac_try='test -s conftest$ac_exeext'
     24882  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24883  (eval $ac_try) 2>&5
     24884  ac_status=$?
     24885  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24886  (exit $ac_status); }; }; then
     24887  coin_add_fflags="-mno-cygwin $coin_add_fflags"
     24888else
     24889  echo "$as_me: failed program was:" >&5
     24890sed 's/^/| /' conftest.$ac_ext >&5
     24891
     24892fi
     24893rm -f conftest.err conftest.$ac_objext \
     24894      conftest$ac_exeext conftest.$ac_ext
     24895        FFLAGS=
     24896      ;;
     24897    esac
     24898  else
     24899    case $build in
     24900      *-cygwin* | *-mingw*)
     24901        case $F77 in
     24902          ifort* | */ifort* | IFORT* | */IFORT* )
     24903            coin_opt_fflags='-MT -O3'
     24904            coin_add_fflags='-fpp -nologo'
     24905            coin_dbg_fflags='-MTd -debug'
     24906          ;;
     24907          compile_f2c*)
     24908            coin_opt_fflags='-MT -O2'
     24909            coin_add_fflags='-nologo -wd4996'
     24910            coin_dbg_fflags='-MTd'
     24911          ;;
     24912        esac
     24913        ;;
     24914      *-linux-*)
     24915        case $F77 in
     24916          ifc* | */ifc* | ifort* | */ifort*)
     24917            coin_opt_fflags="-O3 -ip"
     24918            coin_add_fflags="-cm -w90 -w95"
     24919            coin_dbg_fflags="-g -CA -CB -CS"
     24920            # Check if -i_dynamic is necessary (for new glibc library)
     24921            FFLAGS=
     24922            cat >conftest.$ac_ext <<_ACEOF
     24923      program main
     24924      write(*,*) 'Hello world'
     24925      end
     24926_ACEOF
     24927rm -f conftest.$ac_objext conftest$ac_exeext
     24928if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     24929  (eval $ac_link) 2>conftest.er1
     24930  ac_status=$?
     24931  grep -v '^ *+' conftest.er1 >conftest.err
     24932  rm -f conftest.er1
     24933  cat conftest.err >&5
     24934  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24935  (exit $ac_status); } &&
     24936         { ac_try='test -z "$ac_f77_werror_flag"
     24937                         || test ! -s conftest.err'
     24938  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24939  (eval $ac_try) 2>&5
     24940  ac_status=$?
     24941  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24942  (exit $ac_status); }; } &&
     24943         { ac_try='test -s conftest$ac_exeext'
     24944  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     24945  (eval $ac_try) 2>&5
     24946  ac_status=$?
     24947  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     24948  (exit $ac_status); }; }; then
     24949  :
     24950else
     24951  echo "$as_me: failed program was:" >&5
     24952sed 's/^/| /' conftest.$ac_ext >&5
     24953
     24954coin_add_fflags="-i_dynamic $coin_add_fflags"
     24955fi
     24956rm -f conftest.err conftest.$ac_objext \
     24957      conftest$ac_exeext conftest.$ac_ext
     24958            ;;
     24959          pgf77* | */pgf77* | pgf90* | */pgf90*)
     24960            coin_opt_fflags="-fast"
     24961            coin_add_fflags="-Kieee -pc 64"
     24962            coin_dbg_fflags="-g"
     24963          ;;
     24964        esac
     24965        ;;
     24966      *-ibm-*)
     24967        case "$F77" in
     24968          xlf* | */xlf* | mpxlf* | */mpxlf* )
     24969            coin_opt_fflags="-O -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
     24970            coin_add_fflags="-bmaxdata:0x80000000 -qsuppress=1500-036 -qsuppress=1500-029"
     24971            coin_dbg_fflags="-g -C"
     24972            ;;
     24973        esac
     24974        ;;
     24975      *-hp-*)
     24976        coin_opt_fflags="+O3"
     24977        coin_add_fflags="+U77"
     24978        coin_dbg_fflags="-C -g"
     24979        ;;
     24980      *-*-solaris*)
     24981        coin_opt_fflags="-O4"
     24982        coin_dbg_fflags="-g"
     24983        ;;
     24984      *-sgi-*)
     24985        coin_opt_fflags="-O5 -OPT:Olimit=0"
     24986        coin_dbg_fflags="-g"
     24987        ;;
     24988    esac
     24989  fi
     24990
     24991  if test "$ac_cv_prog_f77_g" = yes && test -z "$coin_dbg_fflags" ; then
     24992    coin_dbg_fflags="-g"
     24993  fi
     24994
     24995  if test -z "$coin_opt_fflags"; then
     24996    # Try if -O option works if nothing else is set
     24997    FFLAGS=-O
     24998    cat >conftest.$ac_ext <<_ACEOF
     24999      program main
     25000      integer i
     25001      end
     25002_ACEOF
     25003rm -f conftest.$ac_objext conftest$ac_exeext
     25004if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25005  (eval $ac_link) 2>conftest.er1
     25006  ac_status=$?
     25007  grep -v '^ *+' conftest.er1 >conftest.err
     25008  rm -f conftest.er1
     25009  cat conftest.err >&5
     25010  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25011  (exit $ac_status); } &&
     25012         { ac_try='test -z "$ac_f77_werror_flag"
     25013                         || test ! -s conftest.err'
     25014  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25015  (eval $ac_try) 2>&5
     25016  ac_status=$?
     25017  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25018  (exit $ac_status); }; } &&
     25019         { ac_try='test -s conftest$ac_exeext'
     25020  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25021  (eval $ac_try) 2>&5
     25022  ac_status=$?
     25023  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25024  (exit $ac_status); }; }; then
     25025  coin_opt_fflags="-O"
     25026else
     25027  echo "$as_me: failed program was:" >&5
     25028sed 's/^/| /' conftest.$ac_ext >&5
     25029
    2317725030fi
    2317825031rm -f conftest.err conftest.$ac_objext \
    2317925032      conftest$ac_exeext conftest.$ac_ext
    2318025033  fi
    23181   if test "x$defval" = "x"; then
    23182     { { echo "$as_me:$LINENO: error: WSMP library $use_wsmp does not seem to work" >&5
     25034
     25035  # if PM doesn't want the warning messages, take them out
     25036  if test x"$coin_skip_warn_fflags" = xyes; then
     25037    coin_warn_fflags=
     25038  fi
     25039
     25040  if test x${DBG_FFLAGS+set} != xset; then
     25041    DBG_FFLAGS="$coin_dbg_fflags $coin_add_fflags $coin_warn_fflags"
     25042  fi
     25043  if test x${OPT_FFLAGS+set} != xset; then
     25044    OPT_FFLAGS="$coin_opt_fflags $coin_add_fflags $coin_warn_fflags"
     25045  fi
     25046
     25047  DBG_FFLAGS="$DBG_FFLAGS $ADD_FFLAGS"
     25048  OPT_FFLAGS="$OPT_FFLAGS $ADD_FFLAGS"
     25049
     25050  if test "$coin_debug_compile" = "true"; then
     25051    FFLAGS="$DBG_FFLAGS"
     25052  else
     25053    FFLAGS="$OPT_FFLAGS"
     25054  fi
     25055else
     25056  FFLAGS="$FFLAGS $ADD_FFLAGS"
     25057  if test x${DBG_FFLAGS+set} != xset; then
     25058    DBG_FFLAGS="$FFLAGS"
     25059  fi
     25060  if test x${OPT_FFLAGS+set} != xset; then
     25061    OPT_FFLAGS="$FFLAGS"
     25062  fi
     25063fi
     25064
     25065# If FFLAGS contains -mno-cygwin, CPPFLAGS must have it.
     25066case "$FFLAGS" in
     25067  *-mno-cygwin*)
     25068    if test x${CPPFLAGS+set} != xset ; then
     25069      CPPFLAGS="-mno-cygwin"
     25070    else
     25071      case "$CPPFLAGS" in
     25072        *-mno-cygwin*)
     25073          ;;
     25074        *)
     25075          CPPFLAGS="$CPPFLAGS -mno-cygwin"
     25076          ;;
     25077      esac
     25078    fi ;;
     25079esac
     25080
     25081# Try if FFLAGS works
     25082if test "$F77" != "unavailable" ; then
     25083  cat >conftest.$ac_ext <<_ACEOF
     25084      program main
     25085      integer i
     25086      end
     25087_ACEOF
     25088rm -f conftest.$ac_objext conftest$ac_exeext
     25089if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25090  (eval $ac_link) 2>conftest.er1
     25091  ac_status=$?
     25092  grep -v '^ *+' conftest.er1 >conftest.err
     25093  rm -f conftest.er1
     25094  cat conftest.err >&5
     25095  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25096  (exit $ac_status); } &&
     25097         { ac_try='test -z "$ac_f77_werror_flag"
     25098                         || test ! -s conftest.err'
     25099  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25100  (eval $ac_try) 2>&5
     25101  ac_status=$?
     25102  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25103  (exit $ac_status); }; } &&
     25104         { ac_try='test -s conftest$ac_exeext'
     25105  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25106  (eval $ac_try) 2>&5
     25107  ac_status=$?
     25108  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25109  (exit $ac_status); }; }; then
     25110  :
     25111else
     25112  echo "$as_me: failed program was:" >&5
     25113sed 's/^/| /' conftest.$ac_ext >&5
     25114
     25115FFLAGS=
     25116fi
     25117rm -f conftest.err conftest.$ac_objext \
     25118      conftest$ac_exeext conftest.$ac_ext
     25119  if test -z "$FFLAGS"; then
     25120    { 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
     25121echo "$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;}
     25122    FFLAGS='-O'
     25123    cat >conftest.$ac_ext <<_ACEOF
     25124      program main
     25125      integer i
     25126      end
     25127_ACEOF
     25128rm -f conftest.$ac_objext conftest$ac_exeext
     25129if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25130  (eval $ac_link) 2>conftest.er1
     25131  ac_status=$?
     25132  grep -v '^ *+' conftest.er1 >conftest.err
     25133  rm -f conftest.er1
     25134  cat conftest.err >&5
     25135  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25136  (exit $ac_status); } &&
     25137         { ac_try='test -z "$ac_f77_werror_flag"
     25138                         || test ! -s conftest.err'
     25139  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25140  (eval $ac_try) 2>&5
     25141  ac_status=$?
     25142  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25143  (exit $ac_status); }; } &&
     25144         { ac_try='test -s conftest$ac_exeext'
     25145  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25146  (eval $ac_try) 2>&5
     25147  ac_status=$?
     25148  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25149  (exit $ac_status); }; }; then
     25150  :
     25151else
     25152  echo "$as_me: failed program was:" >&5
     25153sed 's/^/| /' conftest.$ac_ext >&5
     25154
     25155FFLAGS=
     25156fi
     25157rm -f conftest.err conftest.$ac_objext \
     25158      conftest$ac_exeext conftest.$ac_ext
     25159    if test -z "$FFLAGS"; then
     25160      { 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
     25161echo "$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;}
     25162    fi
     25163  fi
     25164fi
     25165
     25166{ echo "$as_me:$LINENO: Fortran compiler options are: $FFLAGS" >&5
     25167echo "$as_me: Fortran compiler options are: $FFLAGS" >&6;}
     25168
     25169
     25170if test x"$MPIF77" = x; then :; else
     25171  { echo "$as_me:$LINENO: Will use MPI Fortran compiler $MPIF77" >&5
     25172echo "$as_me: Will use MPI Fortran compiler $MPIF77" >&6;}
     25173  F77="$MPIF77"
     25174fi
     25175
     25176# correct the LD variable if we use the intel fortran compiler in windows
     25177case "$F77" in
     25178  ifort* | */ifort* | IFORT* | */IFORT*)
     25179    case $build in
     25180  *-mingw*)
     25181    if test "${LD+set}" = set; then :; else
     25182      LD=link
     25183    fi
     25184    ;;
     25185 esac
     25186 case $enable_doscompile in
     25187   msvc)
     25188     if test "x${LD+set}" = xset; then :; else
     25189       LD=link
     25190     fi
     25191     ;;
     25192 esac
     25193
     25194    ;;
     25195esac
     25196
     25197ac_ext=c
     25198ac_cpp='$CPP $CPPFLAGS'
     25199ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     25200ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25201ac_compiler_gnu=$ac_cv_c_compiler_gnu
     25202
     25203
     25204  ac_ext=f
     25205ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25206ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25207ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25208echo "$as_me:$LINENO: checking how to get verbose linking output from $F77" >&5
     25209echo $ECHO_N "checking how to get verbose linking output from $F77... $ECHO_C" >&6
     25210if test "${ac_cv_prog_f77_v+set}" = set; then
     25211  echo $ECHO_N "(cached) $ECHO_C" >&6
     25212else
     25213  cat >conftest.$ac_ext <<_ACEOF
     25214      program main
     25215
     25216      end
     25217_ACEOF
     25218rm -f conftest.$ac_objext
     25219if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     25220  (eval $ac_compile) 2>conftest.er1
     25221  ac_status=$?
     25222  grep -v '^ *+' conftest.er1 >conftest.err
     25223  rm -f conftest.er1
     25224  cat conftest.err >&5
     25225  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25226  (exit $ac_status); } &&
     25227         { ac_try='test -z "$ac_f77_werror_flag"
     25228                         || test ! -s conftest.err'
     25229  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25230  (eval $ac_try) 2>&5
     25231  ac_status=$?
     25232  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25233  (exit $ac_status); }; } &&
     25234         { ac_try='test -s conftest.$ac_objext'
     25235  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25236  (eval $ac_try) 2>&5
     25237  ac_status=$?
     25238  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25239  (exit $ac_status); }; }; then
     25240  ac_cv_prog_f77_v=
     25241# Try some options frequently used verbose output
     25242for ac_verb in -v -verbose --verbose -V -\#\#\#; do
     25243  cat >conftest.$ac_ext <<_ACEOF
     25244      program main
     25245
     25246      end
     25247_ACEOF
     25248
     25249# Compile and link our simple test program by passing a flag (argument
     25250# 1 to this macro) to the Fortran compiler in order to get
     25251# "verbose" output that we can then parse for the Fortran linker
     25252# flags.
     25253ac_save_FFLAGS=$FFLAGS
     25254FFLAGS="$FFLAGS $ac_verb"
     25255(eval echo $as_me:25255: \"$ac_link\") >&5
     25256ac_f77_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
     25257echo "$ac_f77_v_output" >&5
     25258FFLAGS=$ac_save_FFLAGS
     25259
     25260rm -f conftest*
     25261
     25262# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
     25263# /foo, /bar, and /baz are search directories for the Fortran linker.
     25264# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
     25265ac_f77_v_output="`echo $ac_f77_v_output |
     25266        grep 'LPATH is:' |
     25267        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_f77_v_output"
     25268
     25269case $ac_f77_v_output in
     25270  # If we are using xlf then replace all the commas with spaces.
     25271  *xlfentry*)
     25272    ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'` ;;
     25273
     25274  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
     25275  # $LIBS confuse us, and the libraries appear later in the output anyway).
     25276  *mGLOB_options_string*)
     25277    ac_f77_v_output=`echo $ac_f77_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
     25278
     25279  # If we are using Cray Fortran then delete quotes.
     25280  # Use "\"" instead of '"' for font-lock-mode.
     25281  # FIXME: a more general fix for quoted arguments with spaces?
     25282  *cft90*)
     25283    ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"` ;;
     25284esac
     25285
     25286
     25287  # look for -l* and *.a constructs in the output
     25288  for ac_arg in $ac_f77_v_output; do
     25289     case $ac_arg in
     25290        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
     25291          ac_cv_prog_f77_v=$ac_verb
     25292          break 2 ;;
     25293     esac
     25294  done
     25295done
     25296if test -z "$ac_cv_prog_f77_v"; then
     25297   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F77" >&5
     25298echo "$as_me: WARNING: cannot determine how to obtain linking information from $F77" >&2;}
     25299fi
     25300else
     25301  echo "$as_me: failed program was:" >&5
     25302sed 's/^/| /' conftest.$ac_ext >&5
     25303
     25304{ echo "$as_me:$LINENO: WARNING: compilation failed" >&5
     25305echo "$as_me: WARNING: compilation failed" >&2;}
     25306fi
     25307rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     25308
     25309fi
     25310echo "$as_me:$LINENO: result: $ac_cv_prog_f77_v" >&5
     25311echo "${ECHO_T}$ac_cv_prog_f77_v" >&6
     25312echo "$as_me:$LINENO: checking for Fortran libraries of $F77" >&5
     25313echo $ECHO_N "checking for Fortran libraries of $F77... $ECHO_C" >&6
     25314if test "${ac_cv_f77_libs+set}" = set; then
     25315  echo $ECHO_N "(cached) $ECHO_C" >&6
     25316else
     25317  if test "x$FLIBS" != "x"; then
     25318  ac_cv_f77_libs="$FLIBS" # Let the user override the test.
     25319else
     25320
     25321cat >conftest.$ac_ext <<_ACEOF
     25322      program main
     25323
     25324      end
     25325_ACEOF
     25326
     25327# Compile and link our simple test program by passing a flag (argument
     25328# 1 to this macro) to the Fortran compiler in order to get
     25329# "verbose" output that we can then parse for the Fortran linker
     25330# flags.
     25331ac_save_FFLAGS=$FFLAGS
     25332FFLAGS="$FFLAGS $ac_cv_prog_f77_v"
     25333(eval echo $as_me:25333: \"$ac_link\") >&5
     25334ac_f77_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
     25335echo "$ac_f77_v_output" >&5
     25336FFLAGS=$ac_save_FFLAGS
     25337
     25338rm -f conftest*
     25339
     25340# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
     25341# /foo, /bar, and /baz are search directories for the Fortran linker.
     25342# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
     25343ac_f77_v_output="`echo $ac_f77_v_output |
     25344        grep 'LPATH is:' |
     25345        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_f77_v_output"
     25346
     25347case $ac_f77_v_output in
     25348  # If we are using xlf then replace all the commas with spaces.
     25349  *xlfentry*)
     25350    ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'` ;;
     25351
     25352  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
     25353  # $LIBS confuse us, and the libraries appear later in the output anyway).
     25354  *mGLOB_options_string*)
     25355    ac_f77_v_output=`echo $ac_f77_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
     25356
     25357  # If we are using Cray Fortran then delete quotes.
     25358  # Use "\"" instead of '"' for font-lock-mode.
     25359  # FIXME: a more general fix for quoted arguments with spaces?
     25360  *cft90*)
     25361    ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"` ;;
     25362esac
     25363
     25364
     25365
     25366ac_cv_f77_libs=
     25367
     25368# Save positional arguments (if any)
     25369ac_save_positional="$@"
     25370
     25371set X $ac_f77_v_output
     25372while test $# != 1; do
     25373  shift
     25374  ac_arg=$1
     25375  case $ac_arg in
     25376        [\\/]*.a | ?:[\\/]*.a)
     25377            ac_exists=false
     25378  for ac_i in $ac_cv_f77_libs; do
     25379    if test x"$ac_arg" = x"$ac_i"; then
     25380      ac_exists=true
     25381      break
     25382    fi
     25383  done
     25384
     25385  if test x"$ac_exists" = xtrue; then
     25386  :
     25387else
     25388  ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
     25389fi
     25390
     25391          ;;
     25392        -bI:*)
     25393            ac_exists=false
     25394  for ac_i in $ac_cv_f77_libs; do
     25395    if test x"$ac_arg" = x"$ac_i"; then
     25396      ac_exists=true
     25397      break
     25398    fi
     25399  done
     25400
     25401  if test x"$ac_exists" = xtrue; then
     25402  :
     25403else
     25404  if test "$ac_compiler_gnu" = yes; then
     25405  for ac_link_opt in $ac_arg; do
     25406    ac_cv_f77_libs="$ac_cv_f77_libs -Xlinker $ac_link_opt"
     25407  done
     25408else
     25409  ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
     25410fi
     25411fi
     25412
     25413          ;;
     25414          # Ignore these flags.
     25415        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
     25416          ;;
     25417        -lkernel32)
     25418          test x"$CYGWIN" != xyes && ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
     25419          ;;
     25420        -[LRuY])
     25421          # These flags, when seen by themselves, take an argument.
     25422          # We remove the space between option and argument and re-iterate
     25423          # unless we find an empty arg or a new option (starting with -)
     25424          case $2 in
     25425             "" | -*);;
     25426             *)
     25427                ac_arg="$ac_arg$2"
     25428                shift; shift
     25429                set X $ac_arg "$@"
     25430                ;;
     25431          esac
     25432          ;;
     25433        -YP,*)
     25434          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
     25435              ac_exists=false
     25436  for ac_i in $ac_cv_f77_libs; do
     25437    if test x"$ac_j" = x"$ac_i"; then
     25438      ac_exists=true
     25439      break
     25440    fi
     25441  done
     25442
     25443  if test x"$ac_exists" = xtrue; then
     25444  :
     25445else
     25446  ac_arg="$ac_arg $ac_j"
     25447                               ac_cv_f77_libs="$ac_cv_f77_libs $ac_j"
     25448fi
     25449
     25450          done
     25451          ;;
     25452        -[lLR]*)
     25453            ac_exists=false
     25454  for ac_i in $ac_cv_f77_libs; do
     25455    if test x"$ac_arg" = x"$ac_i"; then
     25456      ac_exists=true
     25457      break
     25458    fi
     25459  done
     25460
     25461  if test x"$ac_exists" = xtrue; then
     25462  :
     25463else
     25464  ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
     25465fi
     25466
     25467          ;;
     25468          # Ignore everything else.
     25469  esac
     25470done
     25471# restore positional arguments
     25472set X $ac_save_positional; shift
     25473
     25474# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
     25475# then we insist that the "run path" must be an absolute path (i.e. it
     25476# must begin with a "/").
     25477case `(uname -sr) 2>/dev/null` in
     25478   "SunOS 5"*)
     25479      ac_ld_run_path=`echo $ac_f77_v_output |
     25480                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
     25481      test "x$ac_ld_run_path" != x &&
     25482        if test "$ac_compiler_gnu" = yes; then
     25483  for ac_link_opt in $ac_ld_run_path; do
     25484    ac_cv_f77_libs="$ac_cv_f77_libs -Xlinker $ac_link_opt"
     25485  done
     25486else
     25487  ac_cv_f77_libs="$ac_cv_f77_libs $ac_ld_run_path"
     25488fi
     25489      ;;
     25490esac
     25491fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
     25492
     25493fi
     25494echo "$as_me:$LINENO: result: $ac_cv_f77_libs" >&5
     25495echo "${ECHO_T}$ac_cv_f77_libs" >&6
     25496FLIBS="$ac_cv_f77_libs"
     25497
     25498
     25499ac_ext=f
     25500ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25501ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25502ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25503
     25504ac_ext=f
     25505ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25506ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25507ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25508
     25509echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
     25510echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
     25511if test "${ac_cv_f77_dummy_main+set}" = set; then
     25512  echo $ECHO_N "(cached) $ECHO_C" >&6
     25513else
     25514  ac_f77_dm_save_LIBS=$LIBS
     25515 LIBS="$LIBS $FLIBS"
     25516 ac_fortran_dm_var=F77_DUMMY_MAIN
     25517 ac_ext=c
     25518ac_cpp='$CPP $CPPFLAGS'
     25519ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     25520ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25521ac_compiler_gnu=$ac_cv_c_compiler_gnu
     25522
     25523 # First, try linking without a dummy main:
     25524 cat >conftest.$ac_ext <<_ACEOF
     25525/* confdefs.h.  */
     25526_ACEOF
     25527cat confdefs.h >>conftest.$ac_ext
     25528cat >>conftest.$ac_ext <<_ACEOF
     25529/* end confdefs.h.  */
     25530
     25531#ifdef F77_DUMMY_MAIN
     25532
     25533#  ifdef __cplusplus
     25534     extern "C"
     25535#  endif
     25536   int F77_DUMMY_MAIN() { return 1; }
     25537
     25538#endif
     25539int
     25540main ()
     25541{
     25542
     25543  ;
     25544  return 0;
     25545}
     25546_ACEOF
     25547rm -f conftest.$ac_objext conftest$ac_exeext
     25548if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25549  (eval $ac_link) 2>conftest.er1
     25550  ac_status=$?
     25551  grep -v '^ *+' conftest.er1 >conftest.err
     25552  rm -f conftest.er1
     25553  cat conftest.err >&5
     25554  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25555  (exit $ac_status); } &&
     25556         { ac_try='test -z "$ac_c_werror_flag"
     25557                         || test ! -s conftest.err'
     25558  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25559  (eval $ac_try) 2>&5
     25560  ac_status=$?
     25561  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25562  (exit $ac_status); }; } &&
     25563         { ac_try='test -s conftest$ac_exeext'
     25564  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25565  (eval $ac_try) 2>&5
     25566  ac_status=$?
     25567  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25568  (exit $ac_status); }; }; then
     25569  ac_cv_fortran_dummy_main=none
     25570else
     25571  echo "$as_me: failed program was:" >&5
     25572sed 's/^/| /' conftest.$ac_ext >&5
     25573
     25574ac_cv_fortran_dummy_main=unknown
     25575fi
     25576rm -f conftest.err conftest.$ac_objext \
     25577      conftest$ac_exeext conftest.$ac_ext
     25578
     25579 if test $ac_cv_fortran_dummy_main = unknown; then
     25580   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
     25581     cat >conftest.$ac_ext <<_ACEOF
     25582/* confdefs.h.  */
     25583_ACEOF
     25584cat confdefs.h >>conftest.$ac_ext
     25585cat >>conftest.$ac_ext <<_ACEOF
     25586/* end confdefs.h.  */
     25587#define $ac_fortran_dm_var $ac_func
     25588#ifdef F77_DUMMY_MAIN
     25589
     25590#  ifdef __cplusplus
     25591     extern "C"
     25592#  endif
     25593   int F77_DUMMY_MAIN() { return 1; }
     25594
     25595#endif
     25596int
     25597main ()
     25598{
     25599
     25600  ;
     25601  return 0;
     25602}
     25603_ACEOF
     25604rm -f conftest.$ac_objext conftest$ac_exeext
     25605if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25606  (eval $ac_link) 2>conftest.er1
     25607  ac_status=$?
     25608  grep -v '^ *+' conftest.er1 >conftest.err
     25609  rm -f conftest.er1
     25610  cat conftest.err >&5
     25611  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25612  (exit $ac_status); } &&
     25613         { ac_try='test -z "$ac_c_werror_flag"
     25614                         || test ! -s conftest.err'
     25615  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25616  (eval $ac_try) 2>&5
     25617  ac_status=$?
     25618  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25619  (exit $ac_status); }; } &&
     25620         { ac_try='test -s conftest$ac_exeext'
     25621  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25622  (eval $ac_try) 2>&5
     25623  ac_status=$?
     25624  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25625  (exit $ac_status); }; }; then
     25626  ac_cv_fortran_dummy_main=$ac_func; break
     25627else
     25628  echo "$as_me: failed program was:" >&5
     25629sed 's/^/| /' conftest.$ac_ext >&5
     25630
     25631fi
     25632rm -f conftest.err conftest.$ac_objext \
     25633      conftest$ac_exeext conftest.$ac_ext
     25634   done
     25635 fi
     25636 ac_ext=f
     25637ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25638ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25639ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25640 ac_cv_f77_dummy_main=$ac_cv_fortran_dummy_main
     25641 rm -f conftest*
     25642 LIBS=$ac_f77_dm_save_LIBS
     25643
     25644fi
     25645echo "$as_me:$LINENO: result: $ac_cv_f77_dummy_main" >&5
     25646echo "${ECHO_T}$ac_cv_f77_dummy_main" >&6
     25647F77_DUMMY_MAIN=$ac_cv_f77_dummy_main
     25648if test "$F77_DUMMY_MAIN" != unknown; then
     25649  if test $F77_DUMMY_MAIN != none; then
     25650
     25651cat >>confdefs.h <<_ACEOF
     25652#define F77_DUMMY_MAIN $F77_DUMMY_MAIN
     25653_ACEOF
     25654
     25655  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
     25656
     25657cat >>confdefs.h <<\_ACEOF
     25658#define FC_DUMMY_MAIN_EQ_F77 1
     25659_ACEOF
     25660
     25661  fi
     25662fi
     25663else
     25664  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
     25665See \`config.log' for more details." >&5
     25666echo "$as_me: error: linking to Fortran libraries from C fails
     25667See \`config.log' for more details." >&2;}
     25668   { (exit 1); exit 1; }; }
     25669fi
     25670
     25671
     25672ac_ext=f
     25673ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25674ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25675ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25676
     25677ac_ext=f
     25678ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25679ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25680ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25681echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
     25682echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
     25683if test "${ac_cv_f77_mangling+set}" = set; then
     25684  echo $ECHO_N "(cached) $ECHO_C" >&6
     25685else
     25686  cat >conftest.$ac_ext <<_ACEOF
     25687      subroutine foobar()
     25688      return
     25689      end
     25690      subroutine foo_bar()
     25691      return
     25692      end
     25693_ACEOF
     25694rm -f conftest.$ac_objext
     25695if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
     25696  (eval $ac_compile) 2>conftest.er1
     25697  ac_status=$?
     25698  grep -v '^ *+' conftest.er1 >conftest.err
     25699  rm -f conftest.er1
     25700  cat conftest.err >&5
     25701  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25702  (exit $ac_status); } &&
     25703         { ac_try='test -z "$ac_f77_werror_flag"
     25704                         || test ! -s conftest.err'
     25705  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25706  (eval $ac_try) 2>&5
     25707  ac_status=$?
     25708  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25709  (exit $ac_status); }; } &&
     25710         { ac_try='test -s conftest.$ac_objext'
     25711  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25712  (eval $ac_try) 2>&5
     25713  ac_status=$?
     25714  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25715  (exit $ac_status); }; }; then
     25716  mv conftest.$ac_objext cfortran_test.$ac_objext
     25717
     25718  ac_save_LIBS=$LIBS
     25719  LIBS="cfortran_test.$ac_objext $LIBS $FLIBS"
     25720
     25721  ac_ext=c
     25722ac_cpp='$CPP $CPPFLAGS'
     25723ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     25724ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25725ac_compiler_gnu=$ac_cv_c_compiler_gnu
     25726  ac_success=no
     25727  for ac_foobar in foobar FOOBAR; do
     25728    for ac_underscore in "" "_"; do
     25729      ac_func="$ac_foobar$ac_underscore"
     25730      cat >conftest.$ac_ext <<_ACEOF
     25731/* confdefs.h.  */
     25732_ACEOF
     25733cat confdefs.h >>conftest.$ac_ext
     25734cat >>conftest.$ac_ext <<_ACEOF
     25735/* end confdefs.h.  */
     25736
     25737/* Override any gcc2 internal prototype to avoid an error.  */
     25738#ifdef __cplusplus
     25739extern "C"
     25740#endif
     25741/* We use char because int might match the return type of a gcc2
     25742   builtin and then its argument prototype would still apply.  */
     25743char $ac_func ();
     25744#ifdef F77_DUMMY_MAIN
     25745
     25746#  ifdef __cplusplus
     25747     extern "C"
     25748#  endif
     25749   int F77_DUMMY_MAIN() { return 1; }
     25750
     25751#endif
     25752int
     25753main ()
     25754{
     25755$ac_func ();
     25756  ;
     25757  return 0;
     25758}
     25759_ACEOF
     25760rm -f conftest.$ac_objext conftest$ac_exeext
     25761if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25762  (eval $ac_link) 2>conftest.er1
     25763  ac_status=$?
     25764  grep -v '^ *+' conftest.er1 >conftest.err
     25765  rm -f conftest.er1
     25766  cat conftest.err >&5
     25767  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25768  (exit $ac_status); } &&
     25769         { ac_try='test -z "$ac_c_werror_flag"
     25770                         || test ! -s conftest.err'
     25771  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25772  (eval $ac_try) 2>&5
     25773  ac_status=$?
     25774  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25775  (exit $ac_status); }; } &&
     25776         { ac_try='test -s conftest$ac_exeext'
     25777  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25778  (eval $ac_try) 2>&5
     25779  ac_status=$?
     25780  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25781  (exit $ac_status); }; }; then
     25782  ac_success=yes; break 2
     25783else
     25784  echo "$as_me: failed program was:" >&5
     25785sed 's/^/| /' conftest.$ac_ext >&5
     25786
     25787fi
     25788rm -f conftest.err conftest.$ac_objext \
     25789      conftest$ac_exeext conftest.$ac_ext
     25790    done
     25791  done
     25792  ac_ext=f
     25793ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25794ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25795ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25796
     25797  if test "$ac_success" = "yes"; then
     25798     case $ac_foobar in
     25799        foobar)
     25800           ac_case=lower
     25801           ac_foo_bar=foo_bar
     25802           ;;
     25803        FOOBAR)
     25804           ac_case=upper
     25805           ac_foo_bar=FOO_BAR
     25806           ;;
     25807     esac
     25808
     25809     ac_ext=c
     25810ac_cpp='$CPP $CPPFLAGS'
     25811ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     25812ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25813ac_compiler_gnu=$ac_cv_c_compiler_gnu
     25814     ac_success_extra=no
     25815     for ac_extra in "" "_"; do
     25816        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
     25817        cat >conftest.$ac_ext <<_ACEOF
     25818/* confdefs.h.  */
     25819_ACEOF
     25820cat confdefs.h >>conftest.$ac_ext
     25821cat >>conftest.$ac_ext <<_ACEOF
     25822/* end confdefs.h.  */
     25823
     25824/* Override any gcc2 internal prototype to avoid an error.  */
     25825#ifdef __cplusplus
     25826extern "C"
     25827#endif
     25828/* We use char because int might match the return type of a gcc2
     25829   builtin and then its argument prototype would still apply.  */
     25830char $ac_func ();
     25831#ifdef F77_DUMMY_MAIN
     25832
     25833#  ifdef __cplusplus
     25834     extern "C"
     25835#  endif
     25836   int F77_DUMMY_MAIN() { return 1; }
     25837
     25838#endif
     25839int
     25840main ()
     25841{
     25842$ac_func ();
     25843  ;
     25844  return 0;
     25845}
     25846_ACEOF
     25847rm -f conftest.$ac_objext conftest$ac_exeext
     25848if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     25849  (eval $ac_link) 2>conftest.er1
     25850  ac_status=$?
     25851  grep -v '^ *+' conftest.er1 >conftest.err
     25852  rm -f conftest.er1
     25853  cat conftest.err >&5
     25854  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25855  (exit $ac_status); } &&
     25856         { ac_try='test -z "$ac_c_werror_flag"
     25857                         || test ! -s conftest.err'
     25858  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25859  (eval $ac_try) 2>&5
     25860  ac_status=$?
     25861  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25862  (exit $ac_status); }; } &&
     25863         { ac_try='test -s conftest$ac_exeext'
     25864  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     25865  (eval $ac_try) 2>&5
     25866  ac_status=$?
     25867  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     25868  (exit $ac_status); }; }; then
     25869  ac_success_extra=yes; break
     25870else
     25871  echo "$as_me: failed program was:" >&5
     25872sed 's/^/| /' conftest.$ac_ext >&5
     25873
     25874fi
     25875rm -f conftest.err conftest.$ac_objext \
     25876      conftest$ac_exeext conftest.$ac_ext
     25877     done
     25878     ac_ext=f
     25879ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25880ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25881ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25882
     25883     if test "$ac_success_extra" = "yes"; then
     25884        ac_cv_f77_mangling="$ac_case case"
     25885        if test -z "$ac_underscore"; then
     25886           ac_cv_f77_mangling="$ac_cv_f77_mangling, no underscore"
     25887        else
     25888           ac_cv_f77_mangling="$ac_cv_f77_mangling, underscore"
     25889        fi
     25890        if test -z "$ac_extra"; then
     25891           ac_cv_f77_mangling="$ac_cv_f77_mangling, no extra underscore"
     25892        else
     25893           ac_cv_f77_mangling="$ac_cv_f77_mangling, extra underscore"
     25894        fi
     25895      else
     25896        ac_cv_f77_mangling="unknown"
     25897      fi
     25898  else
     25899     ac_cv_f77_mangling="unknown"
     25900  fi
     25901
     25902  LIBS=$ac_save_LIBS
     25903  rm -f cfortran_test* conftest*
     25904else
     25905  echo "$as_me: failed program was:" >&5
     25906sed 's/^/| /' conftest.$ac_ext >&5
     25907
     25908{ { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
     25909See \`config.log' for more details." >&5
     25910echo "$as_me: error: cannot compile a simple Fortran program
     25911See \`config.log' for more details." >&2;}
     25912   { (exit 1); exit 1; }; }
     25913fi
     25914rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
     25915
     25916fi
     25917echo "$as_me:$LINENO: result: $ac_cv_f77_mangling" >&5
     25918echo "${ECHO_T}$ac_cv_f77_mangling" >&6
     25919
     25920ac_ext=f
     25921ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25922ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25923ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25924
     25925
     25926ac_ext=f
     25927ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25928ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25929ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25930
     25931
     25932ac_ext=f
     25933ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25934ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25935ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25936
     25937
     25938case $ac_cv_f77_mangling in
     25939  "lower case, no underscore, no extra underscore")
     25940          cat >>confdefs.h <<\_ACEOF
     25941#define F77_FUNC(name,NAME) name
     25942_ACEOF
     25943
     25944          cat >>confdefs.h <<\_ACEOF
     25945#define F77_FUNC_(name,NAME) name
     25946_ACEOF
     25947 ;;
     25948  "lower case, no underscore, extra underscore")
     25949          cat >>confdefs.h <<\_ACEOF
     25950#define F77_FUNC(name,NAME) name
     25951_ACEOF
     25952
     25953          cat >>confdefs.h <<\_ACEOF
     25954#define F77_FUNC_(name,NAME) name ## _
     25955_ACEOF
     25956 ;;
     25957  "lower case, underscore, no extra underscore")
     25958          cat >>confdefs.h <<\_ACEOF
     25959#define F77_FUNC(name,NAME) name ## _
     25960_ACEOF
     25961
     25962          cat >>confdefs.h <<\_ACEOF
     25963#define F77_FUNC_(name,NAME) name ## _
     25964_ACEOF
     25965 ;;
     25966  "lower case, underscore, extra underscore")
     25967          cat >>confdefs.h <<\_ACEOF
     25968#define F77_FUNC(name,NAME) name ## _
     25969_ACEOF
     25970
     25971          cat >>confdefs.h <<\_ACEOF
     25972#define F77_FUNC_(name,NAME) name ## __
     25973_ACEOF
     25974 ;;
     25975  "upper case, no underscore, no extra underscore")
     25976          cat >>confdefs.h <<\_ACEOF
     25977#define F77_FUNC(name,NAME) NAME
     25978_ACEOF
     25979
     25980          cat >>confdefs.h <<\_ACEOF
     25981#define F77_FUNC_(name,NAME) NAME
     25982_ACEOF
     25983 ;;
     25984  "upper case, no underscore, extra underscore")
     25985          cat >>confdefs.h <<\_ACEOF
     25986#define F77_FUNC(name,NAME) NAME
     25987_ACEOF
     25988
     25989          cat >>confdefs.h <<\_ACEOF
     25990#define F77_FUNC_(name,NAME) NAME ## _
     25991_ACEOF
     25992 ;;
     25993  "upper case, underscore, no extra underscore")
     25994          cat >>confdefs.h <<\_ACEOF
     25995#define F77_FUNC(name,NAME) NAME ## _
     25996_ACEOF
     25997
     25998          cat >>confdefs.h <<\_ACEOF
     25999#define F77_FUNC_(name,NAME) NAME ## _
     26000_ACEOF
     26001 ;;
     26002  "upper case, underscore, extra underscore")
     26003          cat >>confdefs.h <<\_ACEOF
     26004#define F77_FUNC(name,NAME) NAME ## _
     26005_ACEOF
     26006
     26007          cat >>confdefs.h <<\_ACEOF
     26008#define F77_FUNC_(name,NAME) NAME ## __
     26009_ACEOF
     26010 ;;
     26011  *)
     26012          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
     26013echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
     26014          ;;
     26015esac
     26016
     26017ac_ext=f
     26018ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     26019ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26020ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     26021
     26022
     26023# If FLIBS has been set by the user, we just restore its value here
     26024if test x"$save_FLIBS" != x; then
     26025  FLIBS="$save_FLIBS"
     26026else
     26027  # This is to correct a missing exclusion in autoconf 2.59
     26028  if test x"$FLIBS" != x; then
     26029    my_flibs=
     26030    for flag in $FLIBS; do
     26031      case $flag in
     26032        -lcrt*.o) ;;
     26033        -lcygwin) ;;
     26034               *) my_flibs="$my_flibs $flag" ;;
     26035      esac
     26036    done
     26037    FLIBS="$my_flibs"
     26038  fi
     26039
     26040  case $build in
     26041  # The following is a fix to define FLIBS for ifort on Windows
     26042  # In its original version, it linked in libifcorert.lib or libifcorertd.lib on Windows/ifort explicitly.
     26043  # However, this seem to create a dependency on libifcorert.dll (or libifcorertd.dll) in the executables.
     26044  # This is seem to be unnecessary, libifcorert(d).lib has been removed from the link line.
     26045  # Further, excluding libc.lib from the default libs seemed to be necessary only for VS < 8.
     26046  # Since the corresponding flag seems to make more trouble that it avoid, it has been removed now.
     26047     *-cygwin* | *-mingw*)
     26048       case "$F77" in
     26049#         ifort* | */ifort* | IFORT* | */IFORT*)
     26050#           FLIBS="-link $LIBS /NODEFAULTLIB:libc.lib"
     26051#           if "$coin_debug_compile" = true ; then
     26052#             FLIBS="-link $LIBS /NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcmt.lib"
     26053#           else
     26054#             FLIBS="-link $LIBS /NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcmtd.lib"
     26055#           fi
     26056#           ;;
     26057         compile_f2c*)
     26058           FLIBS=`$F77 -FLIBS` ;;
     26059       esac;;
     26060     *-hp-*)
     26061         FLIBS="$FLIBS -lm";;
     26062     *-ibm-*)
     26063         FLIBS=`echo $FLIBS | sed 's/-lc)/-lc/g'` ;;
     26064     *-linux-*)
     26065       case "$F77" in
     26066         pgf77* | */pgf77* | pgf90* | */pgf90*)
     26067# ask linker to go through the archives multiple times
     26068# (the Fortran compiler seems to do that automatically...)
     26069           FLIBS="-Wl,--start-group $FLIBS -Wl,--end-group" ;;
     26070       esac
     26071  esac
     26072  ac_cv_f77_libs="$FLIBS"
     26073fi
     26074
     26075ac_ext=c
     26076ac_cpp='$CPP $CPPFLAGS'
     26077ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     26078ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26079ac_compiler_gnu=$ac_cv_c_compiler_gnu
     26080
     26081
     26082
     26083
     26084  # WSMP requires Blas
     26085
     26086
     26087# Check whether --with-blas or --without-blas was given.
     26088if test "${with_blas+set}" = set; then
     26089  withval="$with_blas"
     26090  use_blas="$withval"
     26091else
     26092  use_blas=
     26093fi;
     26094
     26095# if user specified --with-blas-lib, then we should give COIN_CHECK_PACKAGE
     26096# preference
     26097
     26098# Check whether --with-blas-lib or --without-blas-lib was given.
     26099if test "${with_blas_lib+set}" = set; then
     26100  withval="$with_blas_lib"
     26101  use_blas=BUILD
     26102fi;
     26103
     26104# Check if user supplied option makes sense
     26105if test x"$use_blas" != x; then
     26106  if test "$use_blas" = "BUILD"; then
     26107    # we come to this later
     26108    :
     26109  elif test "$use_blas" != "no"; then
     26110    echo "$as_me:$LINENO: checking whether user supplied BLASLIB=\"$use_blas\" works" >&5
     26111echo $ECHO_N "checking whether user supplied BLASLIB=\"$use_blas\" works... $ECHO_C" >&6
     26112    coin_need_flibs=no
     26113    coin_save_LIBS="$LIBS"
     26114    LIBS="$use_blas $LIBS"
     26115    case $ac_ext in
     26116  f)
     26117    cat >conftest.$ac_ext <<_ACEOF
     26118/* confdefs.h.  */
     26119_ACEOF
     26120cat confdefs.h >>conftest.$ac_ext
     26121cat >>conftest.$ac_ext <<_ACEOF
     26122/* end confdefs.h.  */
     26123
     26124#ifdef F77_DUMMY_MAIN
     26125
     26126#  ifdef __cplusplus
     26127     extern "C"
     26128#  endif
     26129   int F77_DUMMY_MAIN() { return 1; }
     26130
     26131#endif
     26132int
     26133main ()
     26134{
     26135      call daxpy
     26136  ;
     26137  return 0;
     26138}
     26139_ACEOF
     26140rm -f conftest.$ac_objext conftest$ac_exeext
     26141if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26142  (eval $ac_link) 2>conftest.er1
     26143  ac_status=$?
     26144  grep -v '^ *+' conftest.er1 >conftest.err
     26145  rm -f conftest.er1
     26146  cat conftest.err >&5
     26147  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26148  (exit $ac_status); } &&
     26149         { ac_try='test -z "$ac_c_werror_flag"
     26150                         || test ! -s conftest.err'
     26151  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26152  (eval $ac_try) 2>&5
     26153  ac_status=$?
     26154  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26155  (exit $ac_status); }; } &&
     26156         { ac_try='test -s conftest$ac_exeext'
     26157  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26158  (eval $ac_try) 2>&5
     26159  ac_status=$?
     26160  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26161  (exit $ac_status); }; }; then
     26162  if test $coin_need_flibs = yes ; then
     26163                         use_blas="$use_blas $FLIBS"
     26164                       fi
     26165                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26166echo "${ECHO_T}yes: $use_blas" >&6
     26167else
     26168  echo "$as_me: failed program was:" >&5
     26169sed 's/^/| /' conftest.$ac_ext >&5
     26170
     26171echo "$as_me:$LINENO: result: no" >&5
     26172echo "${ECHO_T}no" >&6
     26173                       { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
     26174echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
     26175   { (exit 1); exit 1; }; }
     26176fi
     26177rm -f conftest.err conftest.$ac_objext \
     26178      conftest$ac_exeext conftest.$ac_ext
     26179    ;;
     26180  c)
     26181    ac_ext=f
     26182ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     26183ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26184ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     26185case $ac_cv_f77_mangling in
     26186  upper*) ac_val="DAXPY" ;;
     26187  lower*) ac_val="daxpy" ;;
     26188  *)      ac_val="unknown" ;;
     26189esac
     26190case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     26191
     26192cfuncdaxpy="$ac_val"
     26193
     26194ac_ext=c
     26195ac_cpp='$CPP $CPPFLAGS'
     26196ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     26197ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26198ac_compiler_gnu=$ac_cv_c_compiler_gnu
     26199
     26200    if test x"$coin_need_flibs" = xyes; then
     26201      flink_try=no;
     26202    else
     26203      cat >conftest.$ac_ext <<_ACEOF
     26204/* confdefs.h.  */
     26205_ACEOF
     26206cat confdefs.h >>conftest.$ac_ext
     26207cat >>conftest.$ac_ext <<_ACEOF
     26208/* end confdefs.h.  */
     26209void $cfuncdaxpy();
     26210#ifdef F77_DUMMY_MAIN
     26211
     26212#  ifdef __cplusplus
     26213     extern "C"
     26214#  endif
     26215   int F77_DUMMY_MAIN() { return 1; }
     26216
     26217#endif
     26218int
     26219main ()
     26220{
     26221$cfuncdaxpy()
     26222  ;
     26223  return 0;
     26224}
     26225_ACEOF
     26226rm -f conftest.$ac_objext conftest$ac_exeext
     26227if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26228  (eval $ac_link) 2>conftest.er1
     26229  ac_status=$?
     26230  grep -v '^ *+' conftest.er1 >conftest.err
     26231  rm -f conftest.er1
     26232  cat conftest.err >&5
     26233  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26234  (exit $ac_status); } &&
     26235         { ac_try='test -z "$ac_c_werror_flag"
     26236                         || test ! -s conftest.err'
     26237  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26238  (eval $ac_try) 2>&5
     26239  ac_status=$?
     26240  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26241  (exit $ac_status); }; } &&
     26242         { ac_try='test -s conftest$ac_exeext'
     26243  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26244  (eval $ac_try) 2>&5
     26245  ac_status=$?
     26246  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26247  (exit $ac_status); }; }; then
     26248  flink_try=yes
     26249else
     26250  echo "$as_me: failed program was:" >&5
     26251sed 's/^/| /' conftest.$ac_ext >&5
     26252
     26253flink_try=no
     26254fi
     26255rm -f conftest.err conftest.$ac_objext \
     26256      conftest$ac_exeext conftest.$ac_ext
     26257    fi
     26258    if test $flink_try = yes; then
     26259      if test $coin_need_flibs = yes ; then
     26260                         use_blas="$use_blas $FLIBS"
     26261                       fi
     26262                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26263echo "${ECHO_T}yes: $use_blas" >&6
     26264    else
     26265      if test x"$FLIBS" != x; then
     26266        flink_save_libs="$LIBS"
     26267        LIBS="$LIBS $FLIBS"
     26268        cat >conftest.$ac_ext <<_ACEOF
     26269/* confdefs.h.  */
     26270_ACEOF
     26271cat confdefs.h >>conftest.$ac_ext
     26272cat >>conftest.$ac_ext <<_ACEOF
     26273/* end confdefs.h.  */
     26274void $cfuncdaxpy();
     26275#ifdef F77_DUMMY_MAIN
     26276
     26277#  ifdef __cplusplus
     26278     extern "C"
     26279#  endif
     26280   int F77_DUMMY_MAIN() { return 1; }
     26281
     26282#endif
     26283int
     26284main ()
     26285{
     26286$cfuncdaxpy()
     26287  ;
     26288  return 0;
     26289}
     26290_ACEOF
     26291rm -f conftest.$ac_objext conftest$ac_exeext
     26292if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26293  (eval $ac_link) 2>conftest.er1
     26294  ac_status=$?
     26295  grep -v '^ *+' conftest.er1 >conftest.err
     26296  rm -f conftest.er1
     26297  cat conftest.err >&5
     26298  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26299  (exit $ac_status); } &&
     26300         { ac_try='test -z "$ac_c_werror_flag"
     26301                         || test ! -s conftest.err'
     26302  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26303  (eval $ac_try) 2>&5
     26304  ac_status=$?
     26305  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26306  (exit $ac_status); }; } &&
     26307         { ac_try='test -s conftest$ac_exeext'
     26308  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26309  (eval $ac_try) 2>&5
     26310  ac_status=$?
     26311  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26312  (exit $ac_status); }; }; then
     26313  LIBS="$flink_save_libs"
     26314                     coin_need_flibs=yes
     26315                     if test $coin_need_flibs = yes ; then
     26316                         use_blas="$use_blas $FLIBS"
     26317                       fi
     26318                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26319echo "${ECHO_T}yes: $use_blas" >&6
     26320
     26321else
     26322  echo "$as_me: failed program was:" >&5
     26323sed 's/^/| /' conftest.$ac_ext >&5
     26324
     26325LIBS="$flink_save_libs"
     26326                     echo "$as_me:$LINENO: result: no" >&5
     26327echo "${ECHO_T}no" >&6
     26328                       { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
     26329echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
     26330   { (exit 1); exit 1; }; }
     26331fi
     26332rm -f conftest.err conftest.$ac_objext \
     26333      conftest$ac_exeext conftest.$ac_ext
     26334      else
     26335        echo "$as_me:$LINENO: result: no" >&5
     26336echo "${ECHO_T}no" >&6
     26337                       { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
     26338echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
     26339   { (exit 1); exit 1; }; }
     26340      fi
     26341    fi
     26342    ;;
     26343  cc|cpp)
     26344    ac_ext=f
     26345ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     26346ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26347ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     26348case $ac_cv_f77_mangling in
     26349  upper*) ac_val="DAXPY" ;;
     26350  lower*) ac_val="daxpy" ;;
     26351  *)      ac_val="unknown" ;;
     26352esac
     26353case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     26354
     26355cfuncdaxpy="$ac_val"
     26356
     26357ac_ext=c
     26358ac_cpp='$CPP $CPPFLAGS'
     26359ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     26360ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26361ac_compiler_gnu=$ac_cv_c_compiler_gnu
     26362
     26363    if test x"$coin_need_flibs" = xyes; then
     26364      flink_try=no;
     26365    else
     26366      cat >conftest.$ac_ext <<_ACEOF
     26367/* confdefs.h.  */
     26368_ACEOF
     26369cat confdefs.h >>conftest.$ac_ext
     26370cat >>conftest.$ac_ext <<_ACEOF
     26371/* end confdefs.h.  */
     26372extern "C" {void $cfuncdaxpy();}
     26373#ifdef F77_DUMMY_MAIN
     26374
     26375#  ifdef __cplusplus
     26376     extern "C"
     26377#  endif
     26378   int F77_DUMMY_MAIN() { return 1; }
     26379
     26380#endif
     26381int
     26382main ()
     26383{
     26384$cfuncdaxpy()
     26385  ;
     26386  return 0;
     26387}
     26388_ACEOF
     26389rm -f conftest.$ac_objext conftest$ac_exeext
     26390if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26391  (eval $ac_link) 2>conftest.er1
     26392  ac_status=$?
     26393  grep -v '^ *+' conftest.er1 >conftest.err
     26394  rm -f conftest.er1
     26395  cat conftest.err >&5
     26396  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26397  (exit $ac_status); } &&
     26398         { ac_try='test -z "$ac_c_werror_flag"
     26399                         || test ! -s conftest.err'
     26400  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26401  (eval $ac_try) 2>&5
     26402  ac_status=$?
     26403  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26404  (exit $ac_status); }; } &&
     26405         { ac_try='test -s conftest$ac_exeext'
     26406  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26407  (eval $ac_try) 2>&5
     26408  ac_status=$?
     26409  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26410  (exit $ac_status); }; }; then
     26411  flink_try=yes
     26412else
     26413  echo "$as_me: failed program was:" >&5
     26414sed 's/^/| /' conftest.$ac_ext >&5
     26415
     26416flink_try=no
     26417fi
     26418rm -f conftest.err conftest.$ac_objext \
     26419      conftest$ac_exeext conftest.$ac_ext
     26420    fi
     26421    if test $flink_try = yes; then
     26422      if test $coin_need_flibs = yes ; then
     26423                         use_blas="$use_blas $FLIBS"
     26424                       fi
     26425                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26426echo "${ECHO_T}yes: $use_blas" >&6
     26427    else
     26428      if test x"$FLIBS" != x; then
     26429        flink_save_libs="$LIBS"
     26430        LIBS="$LIBS $FLIBS"
     26431        cat >conftest.$ac_ext <<_ACEOF
     26432/* confdefs.h.  */
     26433_ACEOF
     26434cat confdefs.h >>conftest.$ac_ext
     26435cat >>conftest.$ac_ext <<_ACEOF
     26436/* end confdefs.h.  */
     26437extern "C" {void $cfuncdaxpy();}
     26438#ifdef F77_DUMMY_MAIN
     26439
     26440#  ifdef __cplusplus
     26441     extern "C"
     26442#  endif
     26443   int F77_DUMMY_MAIN() { return 1; }
     26444
     26445#endif
     26446int
     26447main ()
     26448{
     26449$cfuncdaxpy()
     26450  ;
     26451  return 0;
     26452}
     26453_ACEOF
     26454rm -f conftest.$ac_objext conftest$ac_exeext
     26455if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26456  (eval $ac_link) 2>conftest.er1
     26457  ac_status=$?
     26458  grep -v '^ *+' conftest.er1 >conftest.err
     26459  rm -f conftest.er1
     26460  cat conftest.err >&5
     26461  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26462  (exit $ac_status); } &&
     26463         { ac_try='test -z "$ac_c_werror_flag"
     26464                         || test ! -s conftest.err'
     26465  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26466  (eval $ac_try) 2>&5
     26467  ac_status=$?
     26468  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26469  (exit $ac_status); }; } &&
     26470         { ac_try='test -s conftest$ac_exeext'
     26471  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26472  (eval $ac_try) 2>&5
     26473  ac_status=$?
     26474  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26475  (exit $ac_status); }; }; then
     26476  LIBS="$flink_save_libs"
     26477                     coin_need_flibs=yes
     26478                     if test $coin_need_flibs = yes ; then
     26479                         use_blas="$use_blas $FLIBS"
     26480                       fi
     26481                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26482echo "${ECHO_T}yes: $use_blas" >&6
     26483
     26484else
     26485  echo "$as_me: failed program was:" >&5
     26486sed 's/^/| /' conftest.$ac_ext >&5
     26487
     26488LIBS="$flink_save_libs"
     26489                     echo "$as_me:$LINENO: result: no" >&5
     26490echo "${ECHO_T}no" >&6
     26491                       { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
     26492echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
     26493   { (exit 1); exit 1; }; }
     26494fi
     26495rm -f conftest.err conftest.$ac_objext \
     26496      conftest$ac_exeext conftest.$ac_ext
     26497      else
     26498        echo "$as_me:$LINENO: result: no" >&5
     26499echo "${ECHO_T}no" >&6
     26500                       { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
     26501echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
     26502   { (exit 1); exit 1; }; }
     26503      fi
     26504    fi
     26505    ;;
     26506esac
     26507
     26508    LIBS="$coin_save_LIBS"
     26509  fi
     26510else
     26511# Try to autodetect the library for blas based on build system
     26512  #AC_MSG_CHECKING([default locations for BLAS])
     26513  skip_lblas_check=no
     26514  case $build in
     26515    *-sgi-*)
     26516      echo "$as_me:$LINENO: checking whether -lcomplib.sgimath has BLAS" >&5
     26517echo $ECHO_N "checking whether -lcomplib.sgimath has BLAS... $ECHO_C" >&6
     26518      coin_need_flibs=no
     26519      coin_save_LIBS="$LIBS"
     26520      LIBS="-lcomplib.sgimath $LIBS"
     26521      case $ac_ext in
     26522  f)
     26523    cat >conftest.$ac_ext <<_ACEOF
     26524/* confdefs.h.  */
     26525_ACEOF
     26526cat confdefs.h >>conftest.$ac_ext
     26527cat >>conftest.$ac_ext <<_ACEOF
     26528/* end confdefs.h.  */
     26529
     26530#ifdef F77_DUMMY_MAIN
     26531
     26532#  ifdef __cplusplus
     26533     extern "C"
     26534#  endif
     26535   int F77_DUMMY_MAIN() { return 1; }
     26536
     26537#endif
     26538int
     26539main ()
     26540{
     26541      call daxpy
     26542  ;
     26543  return 0;
     26544}
     26545_ACEOF
     26546rm -f conftest.$ac_objext conftest$ac_exeext
     26547if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26548  (eval $ac_link) 2>conftest.er1
     26549  ac_status=$?
     26550  grep -v '^ *+' conftest.er1 >conftest.err
     26551  rm -f conftest.er1
     26552  cat conftest.err >&5
     26553  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26554  (exit $ac_status); } &&
     26555         { ac_try='test -z "$ac_c_werror_flag"
     26556                         || test ! -s conftest.err'
     26557  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26558  (eval $ac_try) 2>&5
     26559  ac_status=$?
     26560  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26561  (exit $ac_status); }; } &&
     26562         { ac_try='test -s conftest$ac_exeext'
     26563  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26564  (eval $ac_try) 2>&5
     26565  ac_status=$?
     26566  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26567  (exit $ac_status); }; }; then
     26568  use_blas="-lcomplib.sgimath"
     26569                         if test $coin_need_flibs = yes ; then
     26570                           use_blas="$use_blas $FLIBS"
     26571                         fi
     26572                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26573echo "${ECHO_T}yes: $use_blas" >&6
     26574
     26575else
     26576  echo "$as_me: failed program was:" >&5
     26577sed 's/^/| /' conftest.$ac_ext >&5
     26578
     26579echo "$as_me:$LINENO: result: no" >&5
     26580echo "${ECHO_T}no" >&6
     26581fi
     26582rm -f conftest.err conftest.$ac_objext \
     26583      conftest$ac_exeext conftest.$ac_ext
     26584    ;;
     26585  c)
     26586    ac_ext=f
     26587ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     26588ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26589ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     26590case $ac_cv_f77_mangling in
     26591  upper*) ac_val="DAXPY" ;;
     26592  lower*) ac_val="daxpy" ;;
     26593  *)      ac_val="unknown" ;;
     26594esac
     26595case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     26596
     26597cfuncdaxpy="$ac_val"
     26598
     26599ac_ext=c
     26600ac_cpp='$CPP $CPPFLAGS'
     26601ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     26602ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26603ac_compiler_gnu=$ac_cv_c_compiler_gnu
     26604
     26605    if test x"$coin_need_flibs" = xyes; then
     26606      flink_try=no;
     26607    else
     26608      cat >conftest.$ac_ext <<_ACEOF
     26609/* confdefs.h.  */
     26610_ACEOF
     26611cat confdefs.h >>conftest.$ac_ext
     26612cat >>conftest.$ac_ext <<_ACEOF
     26613/* end confdefs.h.  */
     26614void $cfuncdaxpy();
     26615#ifdef F77_DUMMY_MAIN
     26616
     26617#  ifdef __cplusplus
     26618     extern "C"
     26619#  endif
     26620   int F77_DUMMY_MAIN() { return 1; }
     26621
     26622#endif
     26623int
     26624main ()
     26625{
     26626$cfuncdaxpy()
     26627  ;
     26628  return 0;
     26629}
     26630_ACEOF
     26631rm -f conftest.$ac_objext conftest$ac_exeext
     26632if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26633  (eval $ac_link) 2>conftest.er1
     26634  ac_status=$?
     26635  grep -v '^ *+' conftest.er1 >conftest.err
     26636  rm -f conftest.er1
     26637  cat conftest.err >&5
     26638  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26639  (exit $ac_status); } &&
     26640         { ac_try='test -z "$ac_c_werror_flag"
     26641                         || test ! -s conftest.err'
     26642  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26643  (eval $ac_try) 2>&5
     26644  ac_status=$?
     26645  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26646  (exit $ac_status); }; } &&
     26647         { ac_try='test -s conftest$ac_exeext'
     26648  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26649  (eval $ac_try) 2>&5
     26650  ac_status=$?
     26651  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26652  (exit $ac_status); }; }; then
     26653  flink_try=yes
     26654else
     26655  echo "$as_me: failed program was:" >&5
     26656sed 's/^/| /' conftest.$ac_ext >&5
     26657
     26658flink_try=no
     26659fi
     26660rm -f conftest.err conftest.$ac_objext \
     26661      conftest$ac_exeext conftest.$ac_ext
     26662    fi
     26663    if test $flink_try = yes; then
     26664      use_blas="-lcomplib.sgimath"
     26665                         if test $coin_need_flibs = yes ; then
     26666                           use_blas="$use_blas $FLIBS"
     26667                         fi
     26668                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26669echo "${ECHO_T}yes: $use_blas" >&6
     26670
     26671    else
     26672      if test x"$FLIBS" != x; then
     26673        flink_save_libs="$LIBS"
     26674        LIBS="$LIBS $FLIBS"
     26675        cat >conftest.$ac_ext <<_ACEOF
     26676/* confdefs.h.  */
     26677_ACEOF
     26678cat confdefs.h >>conftest.$ac_ext
     26679cat >>conftest.$ac_ext <<_ACEOF
     26680/* end confdefs.h.  */
     26681void $cfuncdaxpy();
     26682#ifdef F77_DUMMY_MAIN
     26683
     26684#  ifdef __cplusplus
     26685     extern "C"
     26686#  endif
     26687   int F77_DUMMY_MAIN() { return 1; }
     26688
     26689#endif
     26690int
     26691main ()
     26692{
     26693$cfuncdaxpy()
     26694  ;
     26695  return 0;
     26696}
     26697_ACEOF
     26698rm -f conftest.$ac_objext conftest$ac_exeext
     26699if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26700  (eval $ac_link) 2>conftest.er1
     26701  ac_status=$?
     26702  grep -v '^ *+' conftest.er1 >conftest.err
     26703  rm -f conftest.er1
     26704  cat conftest.err >&5
     26705  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26706  (exit $ac_status); } &&
     26707         { ac_try='test -z "$ac_c_werror_flag"
     26708                         || test ! -s conftest.err'
     26709  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26710  (eval $ac_try) 2>&5
     26711  ac_status=$?
     26712  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26713  (exit $ac_status); }; } &&
     26714         { ac_try='test -s conftest$ac_exeext'
     26715  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26716  (eval $ac_try) 2>&5
     26717  ac_status=$?
     26718  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26719  (exit $ac_status); }; }; then
     26720  LIBS="$flink_save_libs"
     26721                     coin_need_flibs=yes
     26722                     use_blas="-lcomplib.sgimath"
     26723                         if test $coin_need_flibs = yes ; then
     26724                           use_blas="$use_blas $FLIBS"
     26725                         fi
     26726                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26727echo "${ECHO_T}yes: $use_blas" >&6
     26728
     26729
     26730else
     26731  echo "$as_me: failed program was:" >&5
     26732sed 's/^/| /' conftest.$ac_ext >&5
     26733
     26734LIBS="$flink_save_libs"
     26735                     echo "$as_me:$LINENO: result: no" >&5
     26736echo "${ECHO_T}no" >&6
     26737fi
     26738rm -f conftest.err conftest.$ac_objext \
     26739      conftest$ac_exeext conftest.$ac_ext
     26740      else
     26741        echo "$as_me:$LINENO: result: no" >&5
     26742echo "${ECHO_T}no" >&6
     26743      fi
     26744    fi
     26745    ;;
     26746  cc|cpp)
     26747    ac_ext=f
     26748ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     26749ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26750ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     26751case $ac_cv_f77_mangling in
     26752  upper*) ac_val="DAXPY" ;;
     26753  lower*) ac_val="daxpy" ;;
     26754  *)      ac_val="unknown" ;;
     26755esac
     26756case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     26757
     26758cfuncdaxpy="$ac_val"
     26759
     26760ac_ext=c
     26761ac_cpp='$CPP $CPPFLAGS'
     26762ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     26763ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26764ac_compiler_gnu=$ac_cv_c_compiler_gnu
     26765
     26766    if test x"$coin_need_flibs" = xyes; then
     26767      flink_try=no;
     26768    else
     26769      cat >conftest.$ac_ext <<_ACEOF
     26770/* confdefs.h.  */
     26771_ACEOF
     26772cat confdefs.h >>conftest.$ac_ext
     26773cat >>conftest.$ac_ext <<_ACEOF
     26774/* end confdefs.h.  */
     26775extern "C" {void $cfuncdaxpy();}
     26776#ifdef F77_DUMMY_MAIN
     26777
     26778#  ifdef __cplusplus
     26779     extern "C"
     26780#  endif
     26781   int F77_DUMMY_MAIN() { return 1; }
     26782
     26783#endif
     26784int
     26785main ()
     26786{
     26787$cfuncdaxpy()
     26788  ;
     26789  return 0;
     26790}
     26791_ACEOF
     26792rm -f conftest.$ac_objext conftest$ac_exeext
     26793if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26794  (eval $ac_link) 2>conftest.er1
     26795  ac_status=$?
     26796  grep -v '^ *+' conftest.er1 >conftest.err
     26797  rm -f conftest.er1
     26798  cat conftest.err >&5
     26799  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26800  (exit $ac_status); } &&
     26801         { ac_try='test -z "$ac_c_werror_flag"
     26802                         || test ! -s conftest.err'
     26803  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26804  (eval $ac_try) 2>&5
     26805  ac_status=$?
     26806  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26807  (exit $ac_status); }; } &&
     26808         { ac_try='test -s conftest$ac_exeext'
     26809  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26810  (eval $ac_try) 2>&5
     26811  ac_status=$?
     26812  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26813  (exit $ac_status); }; }; then
     26814  flink_try=yes
     26815else
     26816  echo "$as_me: failed program was:" >&5
     26817sed 's/^/| /' conftest.$ac_ext >&5
     26818
     26819flink_try=no
     26820fi
     26821rm -f conftest.err conftest.$ac_objext \
     26822      conftest$ac_exeext conftest.$ac_ext
     26823    fi
     26824    if test $flink_try = yes; then
     26825      use_blas="-lcomplib.sgimath"
     26826                         if test $coin_need_flibs = yes ; then
     26827                           use_blas="$use_blas $FLIBS"
     26828                         fi
     26829                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26830echo "${ECHO_T}yes: $use_blas" >&6
     26831
     26832    else
     26833      if test x"$FLIBS" != x; then
     26834        flink_save_libs="$LIBS"
     26835        LIBS="$LIBS $FLIBS"
     26836        cat >conftest.$ac_ext <<_ACEOF
     26837/* confdefs.h.  */
     26838_ACEOF
     26839cat confdefs.h >>conftest.$ac_ext
     26840cat >>conftest.$ac_ext <<_ACEOF
     26841/* end confdefs.h.  */
     26842extern "C" {void $cfuncdaxpy();}
     26843#ifdef F77_DUMMY_MAIN
     26844
     26845#  ifdef __cplusplus
     26846     extern "C"
     26847#  endif
     26848   int F77_DUMMY_MAIN() { return 1; }
     26849
     26850#endif
     26851int
     26852main ()
     26853{
     26854$cfuncdaxpy()
     26855  ;
     26856  return 0;
     26857}
     26858_ACEOF
     26859rm -f conftest.$ac_objext conftest$ac_exeext
     26860if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26861  (eval $ac_link) 2>conftest.er1
     26862  ac_status=$?
     26863  grep -v '^ *+' conftest.er1 >conftest.err
     26864  rm -f conftest.er1
     26865  cat conftest.err >&5
     26866  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26867  (exit $ac_status); } &&
     26868         { ac_try='test -z "$ac_c_werror_flag"
     26869                         || test ! -s conftest.err'
     26870  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26871  (eval $ac_try) 2>&5
     26872  ac_status=$?
     26873  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26874  (exit $ac_status); }; } &&
     26875         { ac_try='test -s conftest$ac_exeext'
     26876  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26877  (eval $ac_try) 2>&5
     26878  ac_status=$?
     26879  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26880  (exit $ac_status); }; }; then
     26881  LIBS="$flink_save_libs"
     26882                     coin_need_flibs=yes
     26883                     use_blas="-lcomplib.sgimath"
     26884                         if test $coin_need_flibs = yes ; then
     26885                           use_blas="$use_blas $FLIBS"
     26886                         fi
     26887                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26888echo "${ECHO_T}yes: $use_blas" >&6
     26889
     26890
     26891else
     26892  echo "$as_me: failed program was:" >&5
     26893sed 's/^/| /' conftest.$ac_ext >&5
     26894
     26895LIBS="$flink_save_libs"
     26896                     echo "$as_me:$LINENO: result: no" >&5
     26897echo "${ECHO_T}no" >&6
     26898fi
     26899rm -f conftest.err conftest.$ac_objext \
     26900      conftest$ac_exeext conftest.$ac_ext
     26901      else
     26902        echo "$as_me:$LINENO: result: no" >&5
     26903echo "${ECHO_T}no" >&6
     26904      fi
     26905    fi
     26906    ;;
     26907esac
     26908
     26909      LIBS="$coin_save_LIBS"
     26910      ;;
     26911
     26912# Ideally, we'd use -library=sunperf, but it's an imperfect world. Studio
     26913# cc doesn't recognise -library, it wants -xlic_lib. Studio 12 CC doesn't
     26914# recognise -xlic_lib. Libtool doesn't like -xlic_lib anyway. Sun claims
     26915# that CC and cc will understand -library in Studio 13. The main extra
     26916# function of -xlic_lib and -library is to arrange for the Fortran run-time
     26917# libraries to be linked for C++ and C. We can arrange that explicitly.
     26918    *-*-solaris*)
     26919      echo "$as_me:$LINENO: checking for BLAS in libsunperf" >&5
     26920echo $ECHO_N "checking for BLAS in libsunperf... $ECHO_C" >&6
     26921      coin_need_flibs=no
     26922      coin_save_LIBS="$LIBS"
     26923      LIBS="-lsunperf $FLIBS $LIBS"
     26924      case $ac_ext in
     26925  f)
     26926    cat >conftest.$ac_ext <<_ACEOF
     26927/* confdefs.h.  */
     26928_ACEOF
     26929cat confdefs.h >>conftest.$ac_ext
     26930cat >>conftest.$ac_ext <<_ACEOF
     26931/* end confdefs.h.  */
     26932
     26933#ifdef F77_DUMMY_MAIN
     26934
     26935#  ifdef __cplusplus
     26936     extern "C"
     26937#  endif
     26938   int F77_DUMMY_MAIN() { return 1; }
     26939
     26940#endif
     26941int
     26942main ()
     26943{
     26944      call daxpy
     26945  ;
     26946  return 0;
     26947}
     26948_ACEOF
     26949rm -f conftest.$ac_objext conftest$ac_exeext
     26950if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     26951  (eval $ac_link) 2>conftest.er1
     26952  ac_status=$?
     26953  grep -v '^ *+' conftest.er1 >conftest.err
     26954  rm -f conftest.er1
     26955  cat conftest.err >&5
     26956  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26957  (exit $ac_status); } &&
     26958         { ac_try='test -z "$ac_c_werror_flag"
     26959                         || test ! -s conftest.err'
     26960  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26961  (eval $ac_try) 2>&5
     26962  ac_status=$?
     26963  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26964  (exit $ac_status); }; } &&
     26965         { ac_try='test -s conftest$ac_exeext'
     26966  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     26967  (eval $ac_try) 2>&5
     26968  ac_status=$?
     26969  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     26970  (exit $ac_status); }; }; then
     26971  use_blas='-lsunperf'
     26972                         if test $coin_need_flibs = yes ; then
     26973                           use_blas="$use_blas $FLIBS"
     26974                         fi
     26975                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     26976echo "${ECHO_T}yes: $use_blas" >&6
     26977
     26978else
     26979  echo "$as_me: failed program was:" >&5
     26980sed 's/^/| /' conftest.$ac_ext >&5
     26981
     26982echo "$as_me:$LINENO: result: no" >&5
     26983echo "${ECHO_T}no" >&6
     26984fi
     26985rm -f conftest.err conftest.$ac_objext \
     26986      conftest$ac_exeext conftest.$ac_ext
     26987    ;;
     26988  c)
     26989    ac_ext=f
     26990ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     26991ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     26992ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     26993case $ac_cv_f77_mangling in
     26994  upper*) ac_val="DAXPY" ;;
     26995  lower*) ac_val="daxpy" ;;
     26996  *)      ac_val="unknown" ;;
     26997esac
     26998case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     26999
     27000cfuncdaxpy="$ac_val"
     27001
     27002ac_ext=c
     27003ac_cpp='$CPP $CPPFLAGS'
     27004ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     27005ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27006ac_compiler_gnu=$ac_cv_c_compiler_gnu
     27007
     27008    if test x"$coin_need_flibs" = xyes; then
     27009      flink_try=no;
     27010    else
     27011      cat >conftest.$ac_ext <<_ACEOF
     27012/* confdefs.h.  */
     27013_ACEOF
     27014cat confdefs.h >>conftest.$ac_ext
     27015cat >>conftest.$ac_ext <<_ACEOF
     27016/* end confdefs.h.  */
     27017void $cfuncdaxpy();
     27018#ifdef F77_DUMMY_MAIN
     27019
     27020#  ifdef __cplusplus
     27021     extern "C"
     27022#  endif
     27023   int F77_DUMMY_MAIN() { return 1; }
     27024
     27025#endif
     27026int
     27027main ()
     27028{
     27029$cfuncdaxpy()
     27030  ;
     27031  return 0;
     27032}
     27033_ACEOF
     27034rm -f conftest.$ac_objext conftest$ac_exeext
     27035if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27036  (eval $ac_link) 2>conftest.er1
     27037  ac_status=$?
     27038  grep -v '^ *+' conftest.er1 >conftest.err
     27039  rm -f conftest.er1
     27040  cat conftest.err >&5
     27041  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27042  (exit $ac_status); } &&
     27043         { ac_try='test -z "$ac_c_werror_flag"
     27044                         || test ! -s conftest.err'
     27045  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27046  (eval $ac_try) 2>&5
     27047  ac_status=$?
     27048  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27049  (exit $ac_status); }; } &&
     27050         { ac_try='test -s conftest$ac_exeext'
     27051  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27052  (eval $ac_try) 2>&5
     27053  ac_status=$?
     27054  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27055  (exit $ac_status); }; }; then
     27056  flink_try=yes
     27057else
     27058  echo "$as_me: failed program was:" >&5
     27059sed 's/^/| /' conftest.$ac_ext >&5
     27060
     27061flink_try=no
     27062fi
     27063rm -f conftest.err conftest.$ac_objext \
     27064      conftest$ac_exeext conftest.$ac_ext
     27065    fi
     27066    if test $flink_try = yes; then
     27067      use_blas='-lsunperf'
     27068                         if test $coin_need_flibs = yes ; then
     27069                           use_blas="$use_blas $FLIBS"
     27070                         fi
     27071                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27072echo "${ECHO_T}yes: $use_blas" >&6
     27073
     27074    else
     27075      if test x"$FLIBS" != x; then
     27076        flink_save_libs="$LIBS"
     27077        LIBS="$LIBS $FLIBS"
     27078        cat >conftest.$ac_ext <<_ACEOF
     27079/* confdefs.h.  */
     27080_ACEOF
     27081cat confdefs.h >>conftest.$ac_ext
     27082cat >>conftest.$ac_ext <<_ACEOF
     27083/* end confdefs.h.  */
     27084void $cfuncdaxpy();
     27085#ifdef F77_DUMMY_MAIN
     27086
     27087#  ifdef __cplusplus
     27088     extern "C"
     27089#  endif
     27090   int F77_DUMMY_MAIN() { return 1; }
     27091
     27092#endif
     27093int
     27094main ()
     27095{
     27096$cfuncdaxpy()
     27097  ;
     27098  return 0;
     27099}
     27100_ACEOF
     27101rm -f conftest.$ac_objext conftest$ac_exeext
     27102if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27103  (eval $ac_link) 2>conftest.er1
     27104  ac_status=$?
     27105  grep -v '^ *+' conftest.er1 >conftest.err
     27106  rm -f conftest.er1
     27107  cat conftest.err >&5
     27108  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27109  (exit $ac_status); } &&
     27110         { ac_try='test -z "$ac_c_werror_flag"
     27111                         || test ! -s conftest.err'
     27112  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27113  (eval $ac_try) 2>&5
     27114  ac_status=$?
     27115  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27116  (exit $ac_status); }; } &&
     27117         { ac_try='test -s conftest$ac_exeext'
     27118  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27119  (eval $ac_try) 2>&5
     27120  ac_status=$?
     27121  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27122  (exit $ac_status); }; }; then
     27123  LIBS="$flink_save_libs"
     27124                     coin_need_flibs=yes
     27125                     use_blas='-lsunperf'
     27126                         if test $coin_need_flibs = yes ; then
     27127                           use_blas="$use_blas $FLIBS"
     27128                         fi
     27129                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27130echo "${ECHO_T}yes: $use_blas" >&6
     27131
     27132
     27133else
     27134  echo "$as_me: failed program was:" >&5
     27135sed 's/^/| /' conftest.$ac_ext >&5
     27136
     27137LIBS="$flink_save_libs"
     27138                     echo "$as_me:$LINENO: result: no" >&5
     27139echo "${ECHO_T}no" >&6
     27140fi
     27141rm -f conftest.err conftest.$ac_objext \
     27142      conftest$ac_exeext conftest.$ac_ext
     27143      else
     27144        echo "$as_me:$LINENO: result: no" >&5
     27145echo "${ECHO_T}no" >&6
     27146      fi
     27147    fi
     27148    ;;
     27149  cc|cpp)
     27150    ac_ext=f
     27151ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     27152ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27153ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     27154case $ac_cv_f77_mangling in
     27155  upper*) ac_val="DAXPY" ;;
     27156  lower*) ac_val="daxpy" ;;
     27157  *)      ac_val="unknown" ;;
     27158esac
     27159case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     27160
     27161cfuncdaxpy="$ac_val"
     27162
     27163ac_ext=c
     27164ac_cpp='$CPP $CPPFLAGS'
     27165ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     27166ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27167ac_compiler_gnu=$ac_cv_c_compiler_gnu
     27168
     27169    if test x"$coin_need_flibs" = xyes; then
     27170      flink_try=no;
     27171    else
     27172      cat >conftest.$ac_ext <<_ACEOF
     27173/* confdefs.h.  */
     27174_ACEOF
     27175cat confdefs.h >>conftest.$ac_ext
     27176cat >>conftest.$ac_ext <<_ACEOF
     27177/* end confdefs.h.  */
     27178extern "C" {void $cfuncdaxpy();}
     27179#ifdef F77_DUMMY_MAIN
     27180
     27181#  ifdef __cplusplus
     27182     extern "C"
     27183#  endif
     27184   int F77_DUMMY_MAIN() { return 1; }
     27185
     27186#endif
     27187int
     27188main ()
     27189{
     27190$cfuncdaxpy()
     27191  ;
     27192  return 0;
     27193}
     27194_ACEOF
     27195rm -f conftest.$ac_objext conftest$ac_exeext
     27196if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27197  (eval $ac_link) 2>conftest.er1
     27198  ac_status=$?
     27199  grep -v '^ *+' conftest.er1 >conftest.err
     27200  rm -f conftest.er1
     27201  cat conftest.err >&5
     27202  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27203  (exit $ac_status); } &&
     27204         { ac_try='test -z "$ac_c_werror_flag"
     27205                         || test ! -s conftest.err'
     27206  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27207  (eval $ac_try) 2>&5
     27208  ac_status=$?
     27209  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27210  (exit $ac_status); }; } &&
     27211         { ac_try='test -s conftest$ac_exeext'
     27212  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27213  (eval $ac_try) 2>&5
     27214  ac_status=$?
     27215  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27216  (exit $ac_status); }; }; then
     27217  flink_try=yes
     27218else
     27219  echo "$as_me: failed program was:" >&5
     27220sed 's/^/| /' conftest.$ac_ext >&5
     27221
     27222flink_try=no
     27223fi
     27224rm -f conftest.err conftest.$ac_objext \
     27225      conftest$ac_exeext conftest.$ac_ext
     27226    fi
     27227    if test $flink_try = yes; then
     27228      use_blas='-lsunperf'
     27229                         if test $coin_need_flibs = yes ; then
     27230                           use_blas="$use_blas $FLIBS"
     27231                         fi
     27232                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27233echo "${ECHO_T}yes: $use_blas" >&6
     27234
     27235    else
     27236      if test x"$FLIBS" != x; then
     27237        flink_save_libs="$LIBS"
     27238        LIBS="$LIBS $FLIBS"
     27239        cat >conftest.$ac_ext <<_ACEOF
     27240/* confdefs.h.  */
     27241_ACEOF
     27242cat confdefs.h >>conftest.$ac_ext
     27243cat >>conftest.$ac_ext <<_ACEOF
     27244/* end confdefs.h.  */
     27245extern "C" {void $cfuncdaxpy();}
     27246#ifdef F77_DUMMY_MAIN
     27247
     27248#  ifdef __cplusplus
     27249     extern "C"
     27250#  endif
     27251   int F77_DUMMY_MAIN() { return 1; }
     27252
     27253#endif
     27254int
     27255main ()
     27256{
     27257$cfuncdaxpy()
     27258  ;
     27259  return 0;
     27260}
     27261_ACEOF
     27262rm -f conftest.$ac_objext conftest$ac_exeext
     27263if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27264  (eval $ac_link) 2>conftest.er1
     27265  ac_status=$?
     27266  grep -v '^ *+' conftest.er1 >conftest.err
     27267  rm -f conftest.er1
     27268  cat conftest.err >&5
     27269  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27270  (exit $ac_status); } &&
     27271         { ac_try='test -z "$ac_c_werror_flag"
     27272                         || test ! -s conftest.err'
     27273  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27274  (eval $ac_try) 2>&5
     27275  ac_status=$?
     27276  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27277  (exit $ac_status); }; } &&
     27278         { ac_try='test -s conftest$ac_exeext'
     27279  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27280  (eval $ac_try) 2>&5
     27281  ac_status=$?
     27282  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27283  (exit $ac_status); }; }; then
     27284  LIBS="$flink_save_libs"
     27285                     coin_need_flibs=yes
     27286                     use_blas='-lsunperf'
     27287                         if test $coin_need_flibs = yes ; then
     27288                           use_blas="$use_blas $FLIBS"
     27289                         fi
     27290                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27291echo "${ECHO_T}yes: $use_blas" >&6
     27292
     27293
     27294else
     27295  echo "$as_me: failed program was:" >&5
     27296sed 's/^/| /' conftest.$ac_ext >&5
     27297
     27298LIBS="$flink_save_libs"
     27299                     echo "$as_me:$LINENO: result: no" >&5
     27300echo "${ECHO_T}no" >&6
     27301fi
     27302rm -f conftest.err conftest.$ac_objext \
     27303      conftest$ac_exeext conftest.$ac_ext
     27304      else
     27305        echo "$as_me:$LINENO: result: no" >&5
     27306echo "${ECHO_T}no" >&6
     27307      fi
     27308    fi
     27309    ;;
     27310esac
     27311
     27312      LIBS="$coin_save_LIBS"
     27313      ;;
     27314
     27315    *-cygwin* | *-mingw*)
     27316# On cygwin, consider -lblas only if doscompile is disabled. The prebuilt
     27317# library will want to link with cygwin, hence won't run standalone in DOS.
     27318      if test "$enable_doscompile" = mingw; then
     27319        skip_lblas_check=yes
     27320      fi
     27321      case "$CC" in
     27322        cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
     27323          coin_save_LIBS="$LIBS"
     27324          echo "$as_me:$LINENO: checking for BLAS in MKL (32bit)" >&5
     27325echo $ECHO_N "checking for BLAS in MKL (32bit)... $ECHO_C" >&6
     27326          LIBS="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib $LIBS"
     27327          case $ac_ext in
     27328  f)
     27329    cat >conftest.$ac_ext <<_ACEOF
     27330/* confdefs.h.  */
     27331_ACEOF
     27332cat confdefs.h >>conftest.$ac_ext
     27333cat >>conftest.$ac_ext <<_ACEOF
     27334/* end confdefs.h.  */
     27335
     27336#ifdef F77_DUMMY_MAIN
     27337
     27338#  ifdef __cplusplus
     27339     extern "C"
     27340#  endif
     27341   int F77_DUMMY_MAIN() { return 1; }
     27342
     27343#endif
     27344int
     27345main ()
     27346{
     27347      call daxpy
     27348  ;
     27349  return 0;
     27350}
     27351_ACEOF
     27352rm -f conftest.$ac_objext conftest$ac_exeext
     27353if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27354  (eval $ac_link) 2>conftest.er1
     27355  ac_status=$?
     27356  grep -v '^ *+' conftest.er1 >conftest.err
     27357  rm -f conftest.er1
     27358  cat conftest.err >&5
     27359  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27360  (exit $ac_status); } &&
     27361         { ac_try='test -z "$ac_c_werror_flag"
     27362                         || test ! -s conftest.err'
     27363  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27364  (eval $ac_try) 2>&5
     27365  ac_status=$?
     27366  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27367  (exit $ac_status); }; } &&
     27368         { ac_try='test -s conftest$ac_exeext'
     27369  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27370  (eval $ac_try) 2>&5
     27371  ac_status=$?
     27372  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27373  (exit $ac_status); }; }; then
     27374  use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib'
     27375                             echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27376echo "${ECHO_T}yes: $use_blas" >&6
     27377
     27378else
     27379  echo "$as_me: failed program was:" >&5
     27380sed 's/^/| /' conftest.$ac_ext >&5
     27381
     27382echo "$as_me:$LINENO: result: no" >&5
     27383echo "${ECHO_T}no" >&6
     27384fi
     27385rm -f conftest.err conftest.$ac_objext \
     27386      conftest$ac_exeext conftest.$ac_ext
     27387    ;;
     27388  c)
     27389    ac_ext=f
     27390ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     27391ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27392ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     27393case $ac_cv_f77_mangling in
     27394  upper*) ac_val="DAXPY" ;;
     27395  lower*) ac_val="daxpy" ;;
     27396  *)      ac_val="unknown" ;;
     27397esac
     27398case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     27399
     27400cfuncdaxpy="$ac_val"
     27401
     27402ac_ext=c
     27403ac_cpp='$CPP $CPPFLAGS'
     27404ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     27405ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27406ac_compiler_gnu=$ac_cv_c_compiler_gnu
     27407
     27408    if test x"$coin_need_flibs" = xyes; then
     27409      flink_try=no;
     27410    else
     27411      cat >conftest.$ac_ext <<_ACEOF
     27412/* confdefs.h.  */
     27413_ACEOF
     27414cat confdefs.h >>conftest.$ac_ext
     27415cat >>conftest.$ac_ext <<_ACEOF
     27416/* end confdefs.h.  */
     27417void $cfuncdaxpy();
     27418#ifdef F77_DUMMY_MAIN
     27419
     27420#  ifdef __cplusplus
     27421     extern "C"
     27422#  endif
     27423   int F77_DUMMY_MAIN() { return 1; }
     27424
     27425#endif
     27426int
     27427main ()
     27428{
     27429$cfuncdaxpy()
     27430  ;
     27431  return 0;
     27432}
     27433_ACEOF
     27434rm -f conftest.$ac_objext conftest$ac_exeext
     27435if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27436  (eval $ac_link) 2>conftest.er1
     27437  ac_status=$?
     27438  grep -v '^ *+' conftest.er1 >conftest.err
     27439  rm -f conftest.er1
     27440  cat conftest.err >&5
     27441  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27442  (exit $ac_status); } &&
     27443         { ac_try='test -z "$ac_c_werror_flag"
     27444                         || test ! -s conftest.err'
     27445  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27446  (eval $ac_try) 2>&5
     27447  ac_status=$?
     27448  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27449  (exit $ac_status); }; } &&
     27450         { ac_try='test -s conftest$ac_exeext'
     27451  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27452  (eval $ac_try) 2>&5
     27453  ac_status=$?
     27454  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27455  (exit $ac_status); }; }; then
     27456  flink_try=yes
     27457else
     27458  echo "$as_me: failed program was:" >&5
     27459sed 's/^/| /' conftest.$ac_ext >&5
     27460
     27461flink_try=no
     27462fi
     27463rm -f conftest.err conftest.$ac_objext \
     27464      conftest$ac_exeext conftest.$ac_ext
     27465    fi
     27466    if test $flink_try = yes; then
     27467      use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib'
     27468                             echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27469echo "${ECHO_T}yes: $use_blas" >&6
     27470
     27471    else
     27472      if test x"$FLIBS" != x; then
     27473        flink_save_libs="$LIBS"
     27474        LIBS="$LIBS $FLIBS"
     27475        cat >conftest.$ac_ext <<_ACEOF
     27476/* confdefs.h.  */
     27477_ACEOF
     27478cat confdefs.h >>conftest.$ac_ext
     27479cat >>conftest.$ac_ext <<_ACEOF
     27480/* end confdefs.h.  */
     27481void $cfuncdaxpy();
     27482#ifdef F77_DUMMY_MAIN
     27483
     27484#  ifdef __cplusplus
     27485     extern "C"
     27486#  endif
     27487   int F77_DUMMY_MAIN() { return 1; }
     27488
     27489#endif
     27490int
     27491main ()
     27492{
     27493$cfuncdaxpy()
     27494  ;
     27495  return 0;
     27496}
     27497_ACEOF
     27498rm -f conftest.$ac_objext conftest$ac_exeext
     27499if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27500  (eval $ac_link) 2>conftest.er1
     27501  ac_status=$?
     27502  grep -v '^ *+' conftest.er1 >conftest.err
     27503  rm -f conftest.er1
     27504  cat conftest.err >&5
     27505  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27506  (exit $ac_status); } &&
     27507         { ac_try='test -z "$ac_c_werror_flag"
     27508                         || test ! -s conftest.err'
     27509  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27510  (eval $ac_try) 2>&5
     27511  ac_status=$?
     27512  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27513  (exit $ac_status); }; } &&
     27514         { ac_try='test -s conftest$ac_exeext'
     27515  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27516  (eval $ac_try) 2>&5
     27517  ac_status=$?
     27518  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27519  (exit $ac_status); }; }; then
     27520  LIBS="$flink_save_libs"
     27521                     coin_need_flibs=yes
     27522                     use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib'
     27523                             echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27524echo "${ECHO_T}yes: $use_blas" >&6
     27525
     27526
     27527else
     27528  echo "$as_me: failed program was:" >&5
     27529sed 's/^/| /' conftest.$ac_ext >&5
     27530
     27531LIBS="$flink_save_libs"
     27532                     echo "$as_me:$LINENO: result: no" >&5
     27533echo "${ECHO_T}no" >&6
     27534fi
     27535rm -f conftest.err conftest.$ac_objext \
     27536      conftest$ac_exeext conftest.$ac_ext
     27537      else
     27538        echo "$as_me:$LINENO: result: no" >&5
     27539echo "${ECHO_T}no" >&6
     27540      fi
     27541    fi
     27542    ;;
     27543  cc|cpp)
     27544    ac_ext=f
     27545ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     27546ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27547ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     27548case $ac_cv_f77_mangling in
     27549  upper*) ac_val="DAXPY" ;;
     27550  lower*) ac_val="daxpy" ;;
     27551  *)      ac_val="unknown" ;;
     27552esac
     27553case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     27554
     27555cfuncdaxpy="$ac_val"
     27556
     27557ac_ext=c
     27558ac_cpp='$CPP $CPPFLAGS'
     27559ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     27560ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27561ac_compiler_gnu=$ac_cv_c_compiler_gnu
     27562
     27563    if test x"$coin_need_flibs" = xyes; then
     27564      flink_try=no;
     27565    else
     27566      cat >conftest.$ac_ext <<_ACEOF
     27567/* confdefs.h.  */
     27568_ACEOF
     27569cat confdefs.h >>conftest.$ac_ext
     27570cat >>conftest.$ac_ext <<_ACEOF
     27571/* end confdefs.h.  */
     27572extern "C" {void $cfuncdaxpy();}
     27573#ifdef F77_DUMMY_MAIN
     27574
     27575#  ifdef __cplusplus
     27576     extern "C"
     27577#  endif
     27578   int F77_DUMMY_MAIN() { return 1; }
     27579
     27580#endif
     27581int
     27582main ()
     27583{
     27584$cfuncdaxpy()
     27585  ;
     27586  return 0;
     27587}
     27588_ACEOF
     27589rm -f conftest.$ac_objext conftest$ac_exeext
     27590if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27591  (eval $ac_link) 2>conftest.er1
     27592  ac_status=$?
     27593  grep -v '^ *+' conftest.er1 >conftest.err
     27594  rm -f conftest.er1
     27595  cat conftest.err >&5
     27596  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27597  (exit $ac_status); } &&
     27598         { ac_try='test -z "$ac_c_werror_flag"
     27599                         || test ! -s conftest.err'
     27600  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27601  (eval $ac_try) 2>&5
     27602  ac_status=$?
     27603  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27604  (exit $ac_status); }; } &&
     27605         { ac_try='test -s conftest$ac_exeext'
     27606  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27607  (eval $ac_try) 2>&5
     27608  ac_status=$?
     27609  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27610  (exit $ac_status); }; }; then
     27611  flink_try=yes
     27612else
     27613  echo "$as_me: failed program was:" >&5
     27614sed 's/^/| /' conftest.$ac_ext >&5
     27615
     27616flink_try=no
     27617fi
     27618rm -f conftest.err conftest.$ac_objext \
     27619      conftest$ac_exeext conftest.$ac_ext
     27620    fi
     27621    if test $flink_try = yes; then
     27622      use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib'
     27623                             echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27624echo "${ECHO_T}yes: $use_blas" >&6
     27625
     27626    else
     27627      if test x"$FLIBS" != x; then
     27628        flink_save_libs="$LIBS"
     27629        LIBS="$LIBS $FLIBS"
     27630        cat >conftest.$ac_ext <<_ACEOF
     27631/* confdefs.h.  */
     27632_ACEOF
     27633cat confdefs.h >>conftest.$ac_ext
     27634cat >>conftest.$ac_ext <<_ACEOF
     27635/* end confdefs.h.  */
     27636extern "C" {void $cfuncdaxpy();}
     27637#ifdef F77_DUMMY_MAIN
     27638
     27639#  ifdef __cplusplus
     27640     extern "C"
     27641#  endif
     27642   int F77_DUMMY_MAIN() { return 1; }
     27643
     27644#endif
     27645int
     27646main ()
     27647{
     27648$cfuncdaxpy()
     27649  ;
     27650  return 0;
     27651}
     27652_ACEOF
     27653rm -f conftest.$ac_objext conftest$ac_exeext
     27654if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27655  (eval $ac_link) 2>conftest.er1
     27656  ac_status=$?
     27657  grep -v '^ *+' conftest.er1 >conftest.err
     27658  rm -f conftest.er1
     27659  cat conftest.err >&5
     27660  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27661  (exit $ac_status); } &&
     27662         { ac_try='test -z "$ac_c_werror_flag"
     27663                         || test ! -s conftest.err'
     27664  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27665  (eval $ac_try) 2>&5
     27666  ac_status=$?
     27667  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27668  (exit $ac_status); }; } &&
     27669         { ac_try='test -s conftest$ac_exeext'
     27670  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27671  (eval $ac_try) 2>&5
     27672  ac_status=$?
     27673  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27674  (exit $ac_status); }; }; then
     27675  LIBS="$flink_save_libs"
     27676                     coin_need_flibs=yes
     27677                     use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib'
     27678                             echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27679echo "${ECHO_T}yes: $use_blas" >&6
     27680
     27681
     27682else
     27683  echo "$as_me: failed program was:" >&5
     27684sed 's/^/| /' conftest.$ac_ext >&5
     27685
     27686LIBS="$flink_save_libs"
     27687                     echo "$as_me:$LINENO: result: no" >&5
     27688echo "${ECHO_T}no" >&6
     27689fi
     27690rm -f conftest.err conftest.$ac_objext \
     27691      conftest$ac_exeext conftest.$ac_ext
     27692      else
     27693        echo "$as_me:$LINENO: result: no" >&5
     27694echo "${ECHO_T}no" >&6
     27695      fi
     27696    fi
     27697    ;;
     27698esac
     27699
     27700          LIBS="$coin_save_LIBS"
     27701
     27702          if test "x$use_blas" = x ; then
     27703            echo "$as_me:$LINENO: checking for BLAS in MKL (64bit)" >&5
     27704echo $ECHO_N "checking for BLAS in MKL (64bit)... $ECHO_C" >&6
     27705            LIBS="mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib $LIBS"
     27706            case $ac_ext in
     27707  f)
     27708    cat >conftest.$ac_ext <<_ACEOF
     27709/* confdefs.h.  */
     27710_ACEOF
     27711cat confdefs.h >>conftest.$ac_ext
     27712cat >>conftest.$ac_ext <<_ACEOF
     27713/* end confdefs.h.  */
     27714
     27715#ifdef F77_DUMMY_MAIN
     27716
     27717#  ifdef __cplusplus
     27718     extern "C"
     27719#  endif
     27720   int F77_DUMMY_MAIN() { return 1; }
     27721
     27722#endif
     27723int
     27724main ()
     27725{
     27726      call daxpy
     27727  ;
     27728  return 0;
     27729}
     27730_ACEOF
     27731rm -f conftest.$ac_objext conftest$ac_exeext
     27732if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27733  (eval $ac_link) 2>conftest.er1
     27734  ac_status=$?
     27735  grep -v '^ *+' conftest.er1 >conftest.err
     27736  rm -f conftest.er1
     27737  cat conftest.err >&5
     27738  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27739  (exit $ac_status); } &&
     27740         { ac_try='test -z "$ac_c_werror_flag"
     27741                         || test ! -s conftest.err'
     27742  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27743  (eval $ac_try) 2>&5
     27744  ac_status=$?
     27745  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27746  (exit $ac_status); }; } &&
     27747         { ac_try='test -s conftest$ac_exeext'
     27748  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27749  (eval $ac_try) 2>&5
     27750  ac_status=$?
     27751  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27752  (exit $ac_status); }; }; then
     27753  use_blas='mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib'
     27754                               echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27755echo "${ECHO_T}yes: $use_blas" >&6
     27756
     27757else
     27758  echo "$as_me: failed program was:" >&5
     27759sed 's/^/| /' conftest.$ac_ext >&5
     27760
     27761echo "$as_me:$LINENO: result: no" >&5
     27762echo "${ECHO_T}no" >&6
     27763fi
     27764rm -f conftest.err conftest.$ac_objext \
     27765      conftest$ac_exeext conftest.$ac_ext
     27766    ;;
     27767  c)
     27768    ac_ext=f
     27769ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     27770ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27771ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     27772case $ac_cv_f77_mangling in
     27773  upper*) ac_val="DAXPY" ;;
     27774  lower*) ac_val="daxpy" ;;
     27775  *)      ac_val="unknown" ;;
     27776esac
     27777case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     27778
     27779cfuncdaxpy="$ac_val"
     27780
     27781ac_ext=c
     27782ac_cpp='$CPP $CPPFLAGS'
     27783ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     27784ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27785ac_compiler_gnu=$ac_cv_c_compiler_gnu
     27786
     27787    if test x"$coin_need_flibs" = xyes; then
     27788      flink_try=no;
     27789    else
     27790      cat >conftest.$ac_ext <<_ACEOF
     27791/* confdefs.h.  */
     27792_ACEOF
     27793cat confdefs.h >>conftest.$ac_ext
     27794cat >>conftest.$ac_ext <<_ACEOF
     27795/* end confdefs.h.  */
     27796void $cfuncdaxpy();
     27797#ifdef F77_DUMMY_MAIN
     27798
     27799#  ifdef __cplusplus
     27800     extern "C"
     27801#  endif
     27802   int F77_DUMMY_MAIN() { return 1; }
     27803
     27804#endif
     27805int
     27806main ()
     27807{
     27808$cfuncdaxpy()
     27809  ;
     27810  return 0;
     27811}
     27812_ACEOF
     27813rm -f conftest.$ac_objext conftest$ac_exeext
     27814if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27815  (eval $ac_link) 2>conftest.er1
     27816  ac_status=$?
     27817  grep -v '^ *+' conftest.er1 >conftest.err
     27818  rm -f conftest.er1
     27819  cat conftest.err >&5
     27820  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27821  (exit $ac_status); } &&
     27822         { ac_try='test -z "$ac_c_werror_flag"
     27823                         || test ! -s conftest.err'
     27824  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27825  (eval $ac_try) 2>&5
     27826  ac_status=$?
     27827  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27828  (exit $ac_status); }; } &&
     27829         { ac_try='test -s conftest$ac_exeext'
     27830  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27831  (eval $ac_try) 2>&5
     27832  ac_status=$?
     27833  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27834  (exit $ac_status); }; }; then
     27835  flink_try=yes
     27836else
     27837  echo "$as_me: failed program was:" >&5
     27838sed 's/^/| /' conftest.$ac_ext >&5
     27839
     27840flink_try=no
     27841fi
     27842rm -f conftest.err conftest.$ac_objext \
     27843      conftest$ac_exeext conftest.$ac_ext
     27844    fi
     27845    if test $flink_try = yes; then
     27846      use_blas='mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib'
     27847                               echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27848echo "${ECHO_T}yes: $use_blas" >&6
     27849
     27850    else
     27851      if test x"$FLIBS" != x; then
     27852        flink_save_libs="$LIBS"
     27853        LIBS="$LIBS $FLIBS"
     27854        cat >conftest.$ac_ext <<_ACEOF
     27855/* confdefs.h.  */
     27856_ACEOF
     27857cat confdefs.h >>conftest.$ac_ext
     27858cat >>conftest.$ac_ext <<_ACEOF
     27859/* end confdefs.h.  */
     27860void $cfuncdaxpy();
     27861#ifdef F77_DUMMY_MAIN
     27862
     27863#  ifdef __cplusplus
     27864     extern "C"
     27865#  endif
     27866   int F77_DUMMY_MAIN() { return 1; }
     27867
     27868#endif
     27869int
     27870main ()
     27871{
     27872$cfuncdaxpy()
     27873  ;
     27874  return 0;
     27875}
     27876_ACEOF
     27877rm -f conftest.$ac_objext conftest$ac_exeext
     27878if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27879  (eval $ac_link) 2>conftest.er1
     27880  ac_status=$?
     27881  grep -v '^ *+' conftest.er1 >conftest.err
     27882  rm -f conftest.er1
     27883  cat conftest.err >&5
     27884  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27885  (exit $ac_status); } &&
     27886         { ac_try='test -z "$ac_c_werror_flag"
     27887                         || test ! -s conftest.err'
     27888  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27889  (eval $ac_try) 2>&5
     27890  ac_status=$?
     27891  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27892  (exit $ac_status); }; } &&
     27893         { ac_try='test -s conftest$ac_exeext'
     27894  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27895  (eval $ac_try) 2>&5
     27896  ac_status=$?
     27897  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27898  (exit $ac_status); }; }; then
     27899  LIBS="$flink_save_libs"
     27900                     coin_need_flibs=yes
     27901                     use_blas='mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib'
     27902                               echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     27903echo "${ECHO_T}yes: $use_blas" >&6
     27904
     27905
     27906else
     27907  echo "$as_me: failed program was:" >&5
     27908sed 's/^/| /' conftest.$ac_ext >&5
     27909
     27910LIBS="$flink_save_libs"
     27911                     echo "$as_me:$LINENO: result: no" >&5
     27912echo "${ECHO_T}no" >&6
     27913fi
     27914rm -f conftest.err conftest.$ac_objext \
     27915      conftest$ac_exeext conftest.$ac_ext
     27916      else
     27917        echo "$as_me:$LINENO: result: no" >&5
     27918echo "${ECHO_T}no" >&6
     27919      fi
     27920    fi
     27921    ;;
     27922  cc|cpp)
     27923    ac_ext=f
     27924ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     27925ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27926ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     27927case $ac_cv_f77_mangling in
     27928  upper*) ac_val="DAXPY" ;;
     27929  lower*) ac_val="daxpy" ;;
     27930  *)      ac_val="unknown" ;;
     27931esac
     27932case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     27933
     27934cfuncdaxpy="$ac_val"
     27935
     27936ac_ext=c
     27937ac_cpp='$CPP $CPPFLAGS'
     27938ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     27939ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     27940ac_compiler_gnu=$ac_cv_c_compiler_gnu
     27941
     27942    if test x"$coin_need_flibs" = xyes; then
     27943      flink_try=no;
     27944    else
     27945      cat >conftest.$ac_ext <<_ACEOF
     27946/* confdefs.h.  */
     27947_ACEOF
     27948cat confdefs.h >>conftest.$ac_ext
     27949cat >>conftest.$ac_ext <<_ACEOF
     27950/* end confdefs.h.  */
     27951extern "C" {void $cfuncdaxpy();}
     27952#ifdef F77_DUMMY_MAIN
     27953
     27954#  ifdef __cplusplus
     27955     extern "C"
     27956#  endif
     27957   int F77_DUMMY_MAIN() { return 1; }
     27958
     27959#endif
     27960int
     27961main ()
     27962{
     27963$cfuncdaxpy()
     27964  ;
     27965  return 0;
     27966}
     27967_ACEOF
     27968rm -f conftest.$ac_objext conftest$ac_exeext
     27969if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     27970  (eval $ac_link) 2>conftest.er1
     27971  ac_status=$?
     27972  grep -v '^ *+' conftest.er1 >conftest.err
     27973  rm -f conftest.er1
     27974  cat conftest.err >&5
     27975  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27976  (exit $ac_status); } &&
     27977         { ac_try='test -z "$ac_c_werror_flag"
     27978                         || test ! -s conftest.err'
     27979  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27980  (eval $ac_try) 2>&5
     27981  ac_status=$?
     27982  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27983  (exit $ac_status); }; } &&
     27984         { ac_try='test -s conftest$ac_exeext'
     27985  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     27986  (eval $ac_try) 2>&5
     27987  ac_status=$?
     27988  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     27989  (exit $ac_status); }; }; then
     27990  flink_try=yes
     27991else
     27992  echo "$as_me: failed program was:" >&5
     27993sed 's/^/| /' conftest.$ac_ext >&5
     27994
     27995flink_try=no
     27996fi
     27997rm -f conftest.err conftest.$ac_objext \
     27998      conftest$ac_exeext conftest.$ac_ext
     27999    fi
     28000    if test $flink_try = yes; then
     28001      use_blas='mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib'
     28002                               echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28003echo "${ECHO_T}yes: $use_blas" >&6
     28004
     28005    else
     28006      if test x"$FLIBS" != x; then
     28007        flink_save_libs="$LIBS"
     28008        LIBS="$LIBS $FLIBS"
     28009        cat >conftest.$ac_ext <<_ACEOF
     28010/* confdefs.h.  */
     28011_ACEOF
     28012cat confdefs.h >>conftest.$ac_ext
     28013cat >>conftest.$ac_ext <<_ACEOF
     28014/* end confdefs.h.  */
     28015extern "C" {void $cfuncdaxpy();}
     28016#ifdef F77_DUMMY_MAIN
     28017
     28018#  ifdef __cplusplus
     28019     extern "C"
     28020#  endif
     28021   int F77_DUMMY_MAIN() { return 1; }
     28022
     28023#endif
     28024int
     28025main ()
     28026{
     28027$cfuncdaxpy()
     28028  ;
     28029  return 0;
     28030}
     28031_ACEOF
     28032rm -f conftest.$ac_objext conftest$ac_exeext
     28033if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28034  (eval $ac_link) 2>conftest.er1
     28035  ac_status=$?
     28036  grep -v '^ *+' conftest.er1 >conftest.err
     28037  rm -f conftest.er1
     28038  cat conftest.err >&5
     28039  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28040  (exit $ac_status); } &&
     28041         { ac_try='test -z "$ac_c_werror_flag"
     28042                         || test ! -s conftest.err'
     28043  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28044  (eval $ac_try) 2>&5
     28045  ac_status=$?
     28046  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28047  (exit $ac_status); }; } &&
     28048         { ac_try='test -s conftest$ac_exeext'
     28049  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28050  (eval $ac_try) 2>&5
     28051  ac_status=$?
     28052  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28053  (exit $ac_status); }; }; then
     28054  LIBS="$flink_save_libs"
     28055                     coin_need_flibs=yes
     28056                     use_blas='mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib'
     28057                               echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28058echo "${ECHO_T}yes: $use_blas" >&6
     28059
     28060
     28061else
     28062  echo "$as_me: failed program was:" >&5
     28063sed 's/^/| /' conftest.$ac_ext >&5
     28064
     28065LIBS="$flink_save_libs"
     28066                     echo "$as_me:$LINENO: result: no" >&5
     28067echo "${ECHO_T}no" >&6
     28068fi
     28069rm -f conftest.err conftest.$ac_objext \
     28070      conftest$ac_exeext conftest.$ac_ext
     28071      else
     28072        echo "$as_me:$LINENO: result: no" >&5
     28073echo "${ECHO_T}no" >&6
     28074      fi
     28075    fi
     28076    ;;
     28077esac
     28078
     28079            LIBS="$coin_save_LIBS"
     28080          fi
     28081          ;;
     28082      esac
     28083      ;;
     28084
     28085     *-darwin*)
     28086      echo "$as_me:$LINENO: checking for BLAS in Veclib" >&5
     28087echo $ECHO_N "checking for BLAS in Veclib... $ECHO_C" >&6
     28088      coin_need_flibs=no
     28089      coin_save_LIBS="$LIBS"
     28090      LIBS="-framework vecLib $LIBS"
     28091      case $ac_ext in
     28092  f)
     28093    cat >conftest.$ac_ext <<_ACEOF
     28094/* confdefs.h.  */
     28095_ACEOF
     28096cat confdefs.h >>conftest.$ac_ext
     28097cat >>conftest.$ac_ext <<_ACEOF
     28098/* end confdefs.h.  */
     28099
     28100#ifdef F77_DUMMY_MAIN
     28101
     28102#  ifdef __cplusplus
     28103     extern "C"
     28104#  endif
     28105   int F77_DUMMY_MAIN() { return 1; }
     28106
     28107#endif
     28108int
     28109main ()
     28110{
     28111      call daxpy
     28112  ;
     28113  return 0;
     28114}
     28115_ACEOF
     28116rm -f conftest.$ac_objext conftest$ac_exeext
     28117if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28118  (eval $ac_link) 2>conftest.er1
     28119  ac_status=$?
     28120  grep -v '^ *+' conftest.er1 >conftest.err
     28121  rm -f conftest.er1
     28122  cat conftest.err >&5
     28123  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28124  (exit $ac_status); } &&
     28125         { ac_try='test -z "$ac_c_werror_flag"
     28126                         || test ! -s conftest.err'
     28127  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28128  (eval $ac_try) 2>&5
     28129  ac_status=$?
     28130  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28131  (exit $ac_status); }; } &&
     28132         { ac_try='test -s conftest$ac_exeext'
     28133  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28134  (eval $ac_try) 2>&5
     28135  ac_status=$?
     28136  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28137  (exit $ac_status); }; }; then
     28138  use_blas='-framework vecLib'
     28139                         if test $coin_need_flibs = yes ; then
     28140                           use_blas="$use_blas $FLIBS"
     28141                         fi
     28142                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28143echo "${ECHO_T}yes: $use_blas" >&6
     28144
     28145else
     28146  echo "$as_me: failed program was:" >&5
     28147sed 's/^/| /' conftest.$ac_ext >&5
     28148
     28149echo "$as_me:$LINENO: result: no" >&5
     28150echo "${ECHO_T}no" >&6
     28151fi
     28152rm -f conftest.err conftest.$ac_objext \
     28153      conftest$ac_exeext conftest.$ac_ext
     28154    ;;
     28155  c)
     28156    ac_ext=f
     28157ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     28158ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28159ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     28160case $ac_cv_f77_mangling in
     28161  upper*) ac_val="DAXPY" ;;
     28162  lower*) ac_val="daxpy" ;;
     28163  *)      ac_val="unknown" ;;
     28164esac
     28165case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     28166
     28167cfuncdaxpy="$ac_val"
     28168
     28169ac_ext=c
     28170ac_cpp='$CPP $CPPFLAGS'
     28171ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     28172ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28173ac_compiler_gnu=$ac_cv_c_compiler_gnu
     28174
     28175    if test x"$coin_need_flibs" = xyes; then
     28176      flink_try=no;
     28177    else
     28178      cat >conftest.$ac_ext <<_ACEOF
     28179/* confdefs.h.  */
     28180_ACEOF
     28181cat confdefs.h >>conftest.$ac_ext
     28182cat >>conftest.$ac_ext <<_ACEOF
     28183/* end confdefs.h.  */
     28184void $cfuncdaxpy();
     28185#ifdef F77_DUMMY_MAIN
     28186
     28187#  ifdef __cplusplus
     28188     extern "C"
     28189#  endif
     28190   int F77_DUMMY_MAIN() { return 1; }
     28191
     28192#endif
     28193int
     28194main ()
     28195{
     28196$cfuncdaxpy()
     28197  ;
     28198  return 0;
     28199}
     28200_ACEOF
     28201rm -f conftest.$ac_objext conftest$ac_exeext
     28202if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28203  (eval $ac_link) 2>conftest.er1
     28204  ac_status=$?
     28205  grep -v '^ *+' conftest.er1 >conftest.err
     28206  rm -f conftest.er1
     28207  cat conftest.err >&5
     28208  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28209  (exit $ac_status); } &&
     28210         { ac_try='test -z "$ac_c_werror_flag"
     28211                         || test ! -s conftest.err'
     28212  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28213  (eval $ac_try) 2>&5
     28214  ac_status=$?
     28215  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28216  (exit $ac_status); }; } &&
     28217         { ac_try='test -s conftest$ac_exeext'
     28218  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28219  (eval $ac_try) 2>&5
     28220  ac_status=$?
     28221  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28222  (exit $ac_status); }; }; then
     28223  flink_try=yes
     28224else
     28225  echo "$as_me: failed program was:" >&5
     28226sed 's/^/| /' conftest.$ac_ext >&5
     28227
     28228flink_try=no
     28229fi
     28230rm -f conftest.err conftest.$ac_objext \
     28231      conftest$ac_exeext conftest.$ac_ext
     28232    fi
     28233    if test $flink_try = yes; then
     28234      use_blas='-framework vecLib'
     28235                         if test $coin_need_flibs = yes ; then
     28236                           use_blas="$use_blas $FLIBS"
     28237                         fi
     28238                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28239echo "${ECHO_T}yes: $use_blas" >&6
     28240
     28241    else
     28242      if test x"$FLIBS" != x; then
     28243        flink_save_libs="$LIBS"
     28244        LIBS="$LIBS $FLIBS"
     28245        cat >conftest.$ac_ext <<_ACEOF
     28246/* confdefs.h.  */
     28247_ACEOF
     28248cat confdefs.h >>conftest.$ac_ext
     28249cat >>conftest.$ac_ext <<_ACEOF
     28250/* end confdefs.h.  */
     28251void $cfuncdaxpy();
     28252#ifdef F77_DUMMY_MAIN
     28253
     28254#  ifdef __cplusplus
     28255     extern "C"
     28256#  endif
     28257   int F77_DUMMY_MAIN() { return 1; }
     28258
     28259#endif
     28260int
     28261main ()
     28262{
     28263$cfuncdaxpy()
     28264  ;
     28265  return 0;
     28266}
     28267_ACEOF
     28268rm -f conftest.$ac_objext conftest$ac_exeext
     28269if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28270  (eval $ac_link) 2>conftest.er1
     28271  ac_status=$?
     28272  grep -v '^ *+' conftest.er1 >conftest.err
     28273  rm -f conftest.er1
     28274  cat conftest.err >&5
     28275  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28276  (exit $ac_status); } &&
     28277         { ac_try='test -z "$ac_c_werror_flag"
     28278                         || test ! -s conftest.err'
     28279  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28280  (eval $ac_try) 2>&5
     28281  ac_status=$?
     28282  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28283  (exit $ac_status); }; } &&
     28284         { ac_try='test -s conftest$ac_exeext'
     28285  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28286  (eval $ac_try) 2>&5
     28287  ac_status=$?
     28288  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28289  (exit $ac_status); }; }; then
     28290  LIBS="$flink_save_libs"
     28291                     coin_need_flibs=yes
     28292                     use_blas='-framework vecLib'
     28293                         if test $coin_need_flibs = yes ; then
     28294                           use_blas="$use_blas $FLIBS"
     28295                         fi
     28296                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28297echo "${ECHO_T}yes: $use_blas" >&6
     28298
     28299
     28300else
     28301  echo "$as_me: failed program was:" >&5
     28302sed 's/^/| /' conftest.$ac_ext >&5
     28303
     28304LIBS="$flink_save_libs"
     28305                     echo "$as_me:$LINENO: result: no" >&5
     28306echo "${ECHO_T}no" >&6
     28307fi
     28308rm -f conftest.err conftest.$ac_objext \
     28309      conftest$ac_exeext conftest.$ac_ext
     28310      else
     28311        echo "$as_me:$LINENO: result: no" >&5
     28312echo "${ECHO_T}no" >&6
     28313      fi
     28314    fi
     28315    ;;
     28316  cc|cpp)
     28317    ac_ext=f
     28318ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     28319ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28320ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     28321case $ac_cv_f77_mangling in
     28322  upper*) ac_val="DAXPY" ;;
     28323  lower*) ac_val="daxpy" ;;
     28324  *)      ac_val="unknown" ;;
     28325esac
     28326case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     28327
     28328cfuncdaxpy="$ac_val"
     28329
     28330ac_ext=c
     28331ac_cpp='$CPP $CPPFLAGS'
     28332ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     28333ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28334ac_compiler_gnu=$ac_cv_c_compiler_gnu
     28335
     28336    if test x"$coin_need_flibs" = xyes; then
     28337      flink_try=no;
     28338    else
     28339      cat >conftest.$ac_ext <<_ACEOF
     28340/* confdefs.h.  */
     28341_ACEOF
     28342cat confdefs.h >>conftest.$ac_ext
     28343cat >>conftest.$ac_ext <<_ACEOF
     28344/* end confdefs.h.  */
     28345extern "C" {void $cfuncdaxpy();}
     28346#ifdef F77_DUMMY_MAIN
     28347
     28348#  ifdef __cplusplus
     28349     extern "C"
     28350#  endif
     28351   int F77_DUMMY_MAIN() { return 1; }
     28352
     28353#endif
     28354int
     28355main ()
     28356{
     28357$cfuncdaxpy()
     28358  ;
     28359  return 0;
     28360}
     28361_ACEOF
     28362rm -f conftest.$ac_objext conftest$ac_exeext
     28363if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28364  (eval $ac_link) 2>conftest.er1
     28365  ac_status=$?
     28366  grep -v '^ *+' conftest.er1 >conftest.err
     28367  rm -f conftest.er1
     28368  cat conftest.err >&5
     28369  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28370  (exit $ac_status); } &&
     28371         { ac_try='test -z "$ac_c_werror_flag"
     28372                         || test ! -s conftest.err'
     28373  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28374  (eval $ac_try) 2>&5
     28375  ac_status=$?
     28376  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28377  (exit $ac_status); }; } &&
     28378         { ac_try='test -s conftest$ac_exeext'
     28379  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28380  (eval $ac_try) 2>&5
     28381  ac_status=$?
     28382  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28383  (exit $ac_status); }; }; then
     28384  flink_try=yes
     28385else
     28386  echo "$as_me: failed program was:" >&5
     28387sed 's/^/| /' conftest.$ac_ext >&5
     28388
     28389flink_try=no
     28390fi
     28391rm -f conftest.err conftest.$ac_objext \
     28392      conftest$ac_exeext conftest.$ac_ext
     28393    fi
     28394    if test $flink_try = yes; then
     28395      use_blas='-framework vecLib'
     28396                         if test $coin_need_flibs = yes ; then
     28397                           use_blas="$use_blas $FLIBS"
     28398                         fi
     28399                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28400echo "${ECHO_T}yes: $use_blas" >&6
     28401
     28402    else
     28403      if test x"$FLIBS" != x; then
     28404        flink_save_libs="$LIBS"
     28405        LIBS="$LIBS $FLIBS"
     28406        cat >conftest.$ac_ext <<_ACEOF
     28407/* confdefs.h.  */
     28408_ACEOF
     28409cat confdefs.h >>conftest.$ac_ext
     28410cat >>conftest.$ac_ext <<_ACEOF
     28411/* end confdefs.h.  */
     28412extern "C" {void $cfuncdaxpy();}
     28413#ifdef F77_DUMMY_MAIN
     28414
     28415#  ifdef __cplusplus
     28416     extern "C"
     28417#  endif
     28418   int F77_DUMMY_MAIN() { return 1; }
     28419
     28420#endif
     28421int
     28422main ()
     28423{
     28424$cfuncdaxpy()
     28425  ;
     28426  return 0;
     28427}
     28428_ACEOF
     28429rm -f conftest.$ac_objext conftest$ac_exeext
     28430if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28431  (eval $ac_link) 2>conftest.er1
     28432  ac_status=$?
     28433  grep -v '^ *+' conftest.er1 >conftest.err
     28434  rm -f conftest.er1
     28435  cat conftest.err >&5
     28436  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28437  (exit $ac_status); } &&
     28438         { ac_try='test -z "$ac_c_werror_flag"
     28439                         || test ! -s conftest.err'
     28440  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28441  (eval $ac_try) 2>&5
     28442  ac_status=$?
     28443  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28444  (exit $ac_status); }; } &&
     28445         { ac_try='test -s conftest$ac_exeext'
     28446  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28447  (eval $ac_try) 2>&5
     28448  ac_status=$?
     28449  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28450  (exit $ac_status); }; }; then
     28451  LIBS="$flink_save_libs"
     28452                     coin_need_flibs=yes
     28453                     use_blas='-framework vecLib'
     28454                         if test $coin_need_flibs = yes ; then
     28455                           use_blas="$use_blas $FLIBS"
     28456                         fi
     28457                         echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28458echo "${ECHO_T}yes: $use_blas" >&6
     28459
     28460
     28461else
     28462  echo "$as_me: failed program was:" >&5
     28463sed 's/^/| /' conftest.$ac_ext >&5
     28464
     28465LIBS="$flink_save_libs"
     28466                     echo "$as_me:$LINENO: result: no" >&5
     28467echo "${ECHO_T}no" >&6
     28468fi
     28469rm -f conftest.err conftest.$ac_objext \
     28470      conftest$ac_exeext conftest.$ac_ext
     28471      else
     28472        echo "$as_me:$LINENO: result: no" >&5
     28473echo "${ECHO_T}no" >&6
     28474      fi
     28475    fi
     28476    ;;
     28477esac
     28478
     28479      LIBS="$coin_save_LIBS"
     28480      ;;
     28481  esac
     28482
     28483  if test -z "$use_blas" && test $skip_lblas_check = no; then
     28484    echo "$as_me:$LINENO: checking whether -lblas has BLAS" >&5
     28485echo $ECHO_N "checking whether -lblas has BLAS... $ECHO_C" >&6
     28486    coin_need_flibs=no
     28487    coin_save_LIBS="$LIBS"
     28488    LIBS="-lblas $LIBS"
     28489    case $ac_ext in
     28490  f)
     28491    cat >conftest.$ac_ext <<_ACEOF
     28492/* confdefs.h.  */
     28493_ACEOF
     28494cat confdefs.h >>conftest.$ac_ext
     28495cat >>conftest.$ac_ext <<_ACEOF
     28496/* end confdefs.h.  */
     28497
     28498#ifdef F77_DUMMY_MAIN
     28499
     28500#  ifdef __cplusplus
     28501     extern "C"
     28502#  endif
     28503   int F77_DUMMY_MAIN() { return 1; }
     28504
     28505#endif
     28506int
     28507main ()
     28508{
     28509      call daxpy
     28510  ;
     28511  return 0;
     28512}
     28513_ACEOF
     28514rm -f conftest.$ac_objext conftest$ac_exeext
     28515if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28516  (eval $ac_link) 2>conftest.er1
     28517  ac_status=$?
     28518  grep -v '^ *+' conftest.er1 >conftest.err
     28519  rm -f conftest.er1
     28520  cat conftest.err >&5
     28521  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28522  (exit $ac_status); } &&
     28523         { ac_try='test -z "$ac_c_werror_flag"
     28524                         || test ! -s conftest.err'
     28525  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28526  (eval $ac_try) 2>&5
     28527  ac_status=$?
     28528  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28529  (exit $ac_status); }; } &&
     28530         { ac_try='test -s conftest$ac_exeext'
     28531  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28532  (eval $ac_try) 2>&5
     28533  ac_status=$?
     28534  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28535  (exit $ac_status); }; }; then
     28536  use_blas='-lblas'
     28537                       if test $coin_need_flibs = yes ; then
     28538                         use_blas="$use_blas $FLIBS"
     28539                       fi
     28540                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28541echo "${ECHO_T}yes: $use_blas" >&6
     28542
     28543else
     28544  echo "$as_me: failed program was:" >&5
     28545sed 's/^/| /' conftest.$ac_ext >&5
     28546
     28547echo "$as_me:$LINENO: result: no" >&5
     28548echo "${ECHO_T}no" >&6
     28549fi
     28550rm -f conftest.err conftest.$ac_objext \
     28551      conftest$ac_exeext conftest.$ac_ext
     28552    ;;
     28553  c)
     28554    ac_ext=f
     28555ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     28556ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28557ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     28558case $ac_cv_f77_mangling in
     28559  upper*) ac_val="DAXPY" ;;
     28560  lower*) ac_val="daxpy" ;;
     28561  *)      ac_val="unknown" ;;
     28562esac
     28563case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     28564
     28565cfuncdaxpy="$ac_val"
     28566
     28567ac_ext=c
     28568ac_cpp='$CPP $CPPFLAGS'
     28569ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     28570ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28571ac_compiler_gnu=$ac_cv_c_compiler_gnu
     28572
     28573    if test x"$coin_need_flibs" = xyes; then
     28574      flink_try=no;
     28575    else
     28576      cat >conftest.$ac_ext <<_ACEOF
     28577/* confdefs.h.  */
     28578_ACEOF
     28579cat confdefs.h >>conftest.$ac_ext
     28580cat >>conftest.$ac_ext <<_ACEOF
     28581/* end confdefs.h.  */
     28582void $cfuncdaxpy();
     28583#ifdef F77_DUMMY_MAIN
     28584
     28585#  ifdef __cplusplus
     28586     extern "C"
     28587#  endif
     28588   int F77_DUMMY_MAIN() { return 1; }
     28589
     28590#endif
     28591int
     28592main ()
     28593{
     28594$cfuncdaxpy()
     28595  ;
     28596  return 0;
     28597}
     28598_ACEOF
     28599rm -f conftest.$ac_objext conftest$ac_exeext
     28600if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28601  (eval $ac_link) 2>conftest.er1
     28602  ac_status=$?
     28603  grep -v '^ *+' conftest.er1 >conftest.err
     28604  rm -f conftest.er1
     28605  cat conftest.err >&5
     28606  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28607  (exit $ac_status); } &&
     28608         { ac_try='test -z "$ac_c_werror_flag"
     28609                         || test ! -s conftest.err'
     28610  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28611  (eval $ac_try) 2>&5
     28612  ac_status=$?
     28613  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28614  (exit $ac_status); }; } &&
     28615         { ac_try='test -s conftest$ac_exeext'
     28616  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28617  (eval $ac_try) 2>&5
     28618  ac_status=$?
     28619  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28620  (exit $ac_status); }; }; then
     28621  flink_try=yes
     28622else
     28623  echo "$as_me: failed program was:" >&5
     28624sed 's/^/| /' conftest.$ac_ext >&5
     28625
     28626flink_try=no
     28627fi
     28628rm -f conftest.err conftest.$ac_objext \
     28629      conftest$ac_exeext conftest.$ac_ext
     28630    fi
     28631    if test $flink_try = yes; then
     28632      use_blas='-lblas'
     28633                       if test $coin_need_flibs = yes ; then
     28634                         use_blas="$use_blas $FLIBS"
     28635                       fi
     28636                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28637echo "${ECHO_T}yes: $use_blas" >&6
     28638
     28639    else
     28640      if test x"$FLIBS" != x; then
     28641        flink_save_libs="$LIBS"
     28642        LIBS="$LIBS $FLIBS"
     28643        cat >conftest.$ac_ext <<_ACEOF
     28644/* confdefs.h.  */
     28645_ACEOF
     28646cat confdefs.h >>conftest.$ac_ext
     28647cat >>conftest.$ac_ext <<_ACEOF
     28648/* end confdefs.h.  */
     28649void $cfuncdaxpy();
     28650#ifdef F77_DUMMY_MAIN
     28651
     28652#  ifdef __cplusplus
     28653     extern "C"
     28654#  endif
     28655   int F77_DUMMY_MAIN() { return 1; }
     28656
     28657#endif
     28658int
     28659main ()
     28660{
     28661$cfuncdaxpy()
     28662  ;
     28663  return 0;
     28664}
     28665_ACEOF
     28666rm -f conftest.$ac_objext conftest$ac_exeext
     28667if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28668  (eval $ac_link) 2>conftest.er1
     28669  ac_status=$?
     28670  grep -v '^ *+' conftest.er1 >conftest.err
     28671  rm -f conftest.er1
     28672  cat conftest.err >&5
     28673  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28674  (exit $ac_status); } &&
     28675         { ac_try='test -z "$ac_c_werror_flag"
     28676                         || test ! -s conftest.err'
     28677  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28678  (eval $ac_try) 2>&5
     28679  ac_status=$?
     28680  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28681  (exit $ac_status); }; } &&
     28682         { ac_try='test -s conftest$ac_exeext'
     28683  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28684  (eval $ac_try) 2>&5
     28685  ac_status=$?
     28686  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28687  (exit $ac_status); }; }; then
     28688  LIBS="$flink_save_libs"
     28689                     coin_need_flibs=yes
     28690                     use_blas='-lblas'
     28691                       if test $coin_need_flibs = yes ; then
     28692                         use_blas="$use_blas $FLIBS"
     28693                       fi
     28694                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28695echo "${ECHO_T}yes: $use_blas" >&6
     28696
     28697
     28698else
     28699  echo "$as_me: failed program was:" >&5
     28700sed 's/^/| /' conftest.$ac_ext >&5
     28701
     28702LIBS="$flink_save_libs"
     28703                     echo "$as_me:$LINENO: result: no" >&5
     28704echo "${ECHO_T}no" >&6
     28705fi
     28706rm -f conftest.err conftest.$ac_objext \
     28707      conftest$ac_exeext conftest.$ac_ext
     28708      else
     28709        echo "$as_me:$LINENO: result: no" >&5
     28710echo "${ECHO_T}no" >&6
     28711      fi
     28712    fi
     28713    ;;
     28714  cc|cpp)
     28715    ac_ext=f
     28716ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     28717ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28718ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     28719case $ac_cv_f77_mangling in
     28720  upper*) ac_val="DAXPY" ;;
     28721  lower*) ac_val="daxpy" ;;
     28722  *)      ac_val="unknown" ;;
     28723esac
     28724case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     28725
     28726cfuncdaxpy="$ac_val"
     28727
     28728ac_ext=c
     28729ac_cpp='$CPP $CPPFLAGS'
     28730ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     28731ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     28732ac_compiler_gnu=$ac_cv_c_compiler_gnu
     28733
     28734    if test x"$coin_need_flibs" = xyes; then
     28735      flink_try=no;
     28736    else
     28737      cat >conftest.$ac_ext <<_ACEOF
     28738/* confdefs.h.  */
     28739_ACEOF
     28740cat confdefs.h >>conftest.$ac_ext
     28741cat >>conftest.$ac_ext <<_ACEOF
     28742/* end confdefs.h.  */
     28743extern "C" {void $cfuncdaxpy();}
     28744#ifdef F77_DUMMY_MAIN
     28745
     28746#  ifdef __cplusplus
     28747     extern "C"
     28748#  endif
     28749   int F77_DUMMY_MAIN() { return 1; }
     28750
     28751#endif
     28752int
     28753main ()
     28754{
     28755$cfuncdaxpy()
     28756  ;
     28757  return 0;
     28758}
     28759_ACEOF
     28760rm -f conftest.$ac_objext conftest$ac_exeext
     28761if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28762  (eval $ac_link) 2>conftest.er1
     28763  ac_status=$?
     28764  grep -v '^ *+' conftest.er1 >conftest.err
     28765  rm -f conftest.er1
     28766  cat conftest.err >&5
     28767  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28768  (exit $ac_status); } &&
     28769         { ac_try='test -z "$ac_c_werror_flag"
     28770                         || test ! -s conftest.err'
     28771  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28772  (eval $ac_try) 2>&5
     28773  ac_status=$?
     28774  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28775  (exit $ac_status); }; } &&
     28776         { ac_try='test -s conftest$ac_exeext'
     28777  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28778  (eval $ac_try) 2>&5
     28779  ac_status=$?
     28780  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28781  (exit $ac_status); }; }; then
     28782  flink_try=yes
     28783else
     28784  echo "$as_me: failed program was:" >&5
     28785sed 's/^/| /' conftest.$ac_ext >&5
     28786
     28787flink_try=no
     28788fi
     28789rm -f conftest.err conftest.$ac_objext \
     28790      conftest$ac_exeext conftest.$ac_ext
     28791    fi
     28792    if test $flink_try = yes; then
     28793      use_blas='-lblas'
     28794                       if test $coin_need_flibs = yes ; then
     28795                         use_blas="$use_blas $FLIBS"
     28796                       fi
     28797                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28798echo "${ECHO_T}yes: $use_blas" >&6
     28799
     28800    else
     28801      if test x"$FLIBS" != x; then
     28802        flink_save_libs="$LIBS"
     28803        LIBS="$LIBS $FLIBS"
     28804        cat >conftest.$ac_ext <<_ACEOF
     28805/* confdefs.h.  */
     28806_ACEOF
     28807cat confdefs.h >>conftest.$ac_ext
     28808cat >>conftest.$ac_ext <<_ACEOF
     28809/* end confdefs.h.  */
     28810extern "C" {void $cfuncdaxpy();}
     28811#ifdef F77_DUMMY_MAIN
     28812
     28813#  ifdef __cplusplus
     28814     extern "C"
     28815#  endif
     28816   int F77_DUMMY_MAIN() { return 1; }
     28817
     28818#endif
     28819int
     28820main ()
     28821{
     28822$cfuncdaxpy()
     28823  ;
     28824  return 0;
     28825}
     28826_ACEOF
     28827rm -f conftest.$ac_objext conftest$ac_exeext
     28828if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     28829  (eval $ac_link) 2>conftest.er1
     28830  ac_status=$?
     28831  grep -v '^ *+' conftest.er1 >conftest.err
     28832  rm -f conftest.er1
     28833  cat conftest.err >&5
     28834  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28835  (exit $ac_status); } &&
     28836         { ac_try='test -z "$ac_c_werror_flag"
     28837                         || test ! -s conftest.err'
     28838  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28839  (eval $ac_try) 2>&5
     28840  ac_status=$?
     28841  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28842  (exit $ac_status); }; } &&
     28843         { ac_try='test -s conftest$ac_exeext'
     28844  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     28845  (eval $ac_try) 2>&5
     28846  ac_status=$?
     28847  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     28848  (exit $ac_status); }; }; then
     28849  LIBS="$flink_save_libs"
     28850                     coin_need_flibs=yes
     28851                     use_blas='-lblas'
     28852                       if test $coin_need_flibs = yes ; then
     28853                         use_blas="$use_blas $FLIBS"
     28854                       fi
     28855                       echo "$as_me:$LINENO: result: yes: $use_blas" >&5
     28856echo "${ECHO_T}yes: $use_blas" >&6
     28857
     28858
     28859else
     28860  echo "$as_me: failed program was:" >&5
     28861sed 's/^/| /' conftest.$ac_ext >&5
     28862
     28863LIBS="$flink_save_libs"
     28864                     echo "$as_me:$LINENO: result: no" >&5
     28865echo "${ECHO_T}no" >&6
     28866fi
     28867rm -f conftest.err conftest.$ac_objext \
     28868      conftest$ac_exeext conftest.$ac_ext
     28869      else
     28870        echo "$as_me:$LINENO: result: no" >&5
     28871echo "${ECHO_T}no" >&6
     28872      fi
     28873    fi
     28874    ;;
     28875esac
     28876
     28877    LIBS="$coin_save_LIBS"
     28878  fi
     28879
     28880  # If we have no other ideas, consider building BLAS.
     28881  if test -z "$use_blas" ; then
     28882    use_blas=BUILD
     28883  fi
     28884fi
     28885
     28886if test "x$use_blas" = xBUILD ; then
     28887
     28888echo "$as_me:$LINENO: checking for COIN-OR package Blas" >&5
     28889echo $ECHO_N "checking for COIN-OR package Blas... $ECHO_C" >&6
     28890
     28891coin_has_blas=notGiven
     28892
     28893# check if user wants to skip package in any case
     28894if test x"$COIN_SKIP_PROJECTS" != x; then
     28895  for dir in $COIN_SKIP_PROJECTS; do
     28896    if test $dir = "Blas"; then
     28897      coin_has_blas=skipping
     28898    fi
     28899  done
     28900fi
     28901
     28902BLAS_LIBS=
     28903BLAS_CFLAGS=
     28904BLAS_DATA=
     28905
     28906
     28907
     28908
     28909
     28910
     28911
     28912
     28913
     28914
     28915
     28916
     28917
     28918
     28919
     28920
     28921
     28922#check if user provided LIBS, CFLAGS, or DATA for package or disables use of package
     28923if test $coin_has_blas != skipping; then
     28924
     28925# Check whether --with-m4_tolower(Blas)-lib or --without-m4_tolower(Blas)-lib was given.
     28926if test "${with_blas_lib+set}" = set; then
     28927  withval="$with_blas_lib"
     28928  if test "$withval" = no ; then
     28929       coin_has_blas=skipping
     28930     else
     28931       coin_has_blas=yes
     28932       BLAS_LIBS="$withval"
     28933
     28934         CLPLIB_PCLIBS="$withval $CLPLIB_PCLIBS"
     28935         CLPLIB_LIBS="$withval $CLPLIB_LIBS"
     28936
     28937       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     28938       if test -z "$PKG_CONFIG" ; then
     28939         BLAS_LIBS_INSTALLED="$withval"
     28940         CLPLIB_LIBS_INSTALLED="$withval $CLPLIB_LIBS_INSTALLED"
     28941       fi
     28942     fi
     28943
     28944fi;
     28945fi
     28946
     28947if test $coin_has_blas != skipping; then
     28948
     28949# Check whether --with-m4_tolower(Blas)-incdir or --without-m4_tolower(Blas)-incdir was given.
     28950if test "${with_blas_incdir+set}" = set; then
     28951  withval="$with_blas_incdir"
     28952  if test "$withval" = no ; then
     28953       coin_has_blas=skipping
     28954     else
     28955       coin_has_blas=yes
     28956       BLAS_CFLAGS="-I`${CYGPATH_W} $withval`"
     28957       CLPLIB_CFLAGS="-I`${CYGPATH_W} $withval` $CLPLIB_CFLAGS"
     28958       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     28959       if test -z "$PKG_CONFIG" ; then
     28960         BLAS_CFLAGS_INSTALLED="$BLAS_CFLAGS"
     28961         CLPLIB_CFLAGS_INSTALLED="$BLAS_CFLAGS $CLPLIB_CFLAGS_INSTALLED"
     28962       fi
     28963     fi
     28964
     28965fi;
     28966fi
     28967
     28968if test $coin_has_blas != skipping; then
     28969
     28970# Check whether --with-m4_tolower(Blas)-datadir or --without-m4_tolower(Blas)-datadir was given.
     28971if test "${with_blas_datadir+set}" = set; then
     28972  withval="$with_blas_datadir"
     28973  if test "$withval" = no ; then
     28974       coin_has_blas=skipping
     28975     else
     28976       coin_has_blas=yes
     28977       BLAS_DATA="$withval"
     28978       # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables
     28979       if test -z "$PKG_CONFIG" ; then
     28980         BLAS_DATA_INSTALLED="$withval"
     28981       fi
     28982     fi
     28983
     28984fi;
     28985fi
     28986
     28987if test $coin_has_blas = notGiven; then
     28988  if test -n "$PKG_CONFIG" ; then
     28989    # set search path for pkg-config
     28990    # need to export variable to be sure that the following pkg-config gets these values
     28991    coin_save_PKG_CONFIG_PATH="$PKG_CONFIG_PATH"
     28992    PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH:$COIN_PKG_CONFIG_PATH_UNINSTALLED"
     28993    export PKG_CONFIG_PATH
     28994
     28995    # let pkg-config do it's magic
     28996
     28997
     28998
     28999if test -n "$PKG_CONFIG" ; then
     29000  if $PKG_CONFIG --exists "coinblas"; then
     29001    BLAS_VERSIONS="`$PKG_CONFIG --modversion "coinblas" 2>/dev/null | tr '\n' ' '`"
     29002     cflags=`$PKG_CONFIG --cflags "coinblas" 2>/dev/null`
     29003    # pkg-config cannot handle spaces, so CYGPATH_W cannot be put into .pc files
     29004        # thus, we modify the cflags extracted from pkg-config by putting CYGPATH_W behind -I's
     29005        # but only do this if is not trivial
     29006    if test "$CYGPATH_W" != "echo" ; then
     29007      # need to put into brackets since otherwise autoconf replaces the brackets in the sed command
     29008      cflags=`echo $cflags | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     29009    fi
     29010    BLAS_CFLAGS="$cflags"
     29011    BLAS_LIBS=`$PKG_CONFIG --libs "coinblas" 2>/dev/null`
     29012    BLAS_DATA=`$PKG_CONFIG --variable=datadir "coinblas" 2>/dev/null`
     29013     coin_has_blas=yes
     29014        echo "$as_me:$LINENO: result: yes: $BLAS_VERSIONS" >&5
     29015echo "${ECHO_T}yes: $BLAS_VERSIONS" >&6
     29016
     29017        # adjust linker flags for (i)cl compiler
     29018        # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl)
     29019        if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ;
     29020        then
     29021          BLAS_LIBS=`echo " $BLAS_LIBS " | sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g'`
     29022        fi
     29023
     29024        # augment X_PCREQUIRES, X_CFLAGS, and X_LIBS for each build target X in ClpLib
     29025
     29026          CLPLIB_PCREQUIRES="coinblas $CLPLIB_PCREQUIRES"
     29027          CLPLIB_CFLAGS="$BLAS_CFLAGS $CLPLIB_CFLAGS"
     29028          CLPLIB_LIBS="$BLAS_LIBS $CLPLIB_LIBS"
     29029
     29030
     29031
     29032  else
     29033    BLAS_PKG_ERRORS=`$PKG_CONFIG $pkg_short_errors --errors-to-stdout --print-errors "coinblas"`
     29034      coin_has_blas=notGiven
     29035        echo "$as_me:$LINENO: result: not given: $BLAS_PKG_ERRORS" >&5
     29036echo "${ECHO_T}not given: $BLAS_PKG_ERRORS" >&6
     29037
     29038  fi
     29039else
     29040  { { echo "$as_me:$LINENO: error: \"Cannot check for existance of module Blas without pkg-config\"" >&5
     29041echo "$as_me: error: \"Cannot check for existance of module Blas without pkg-config\"" >&2;}
     29042   { (exit 1); exit 1; }; }
     29043fi
     29044
     29045
     29046
     29047
     29048    # reset PKG_CONFIG_PATH variable
     29049    PKG_CONFIG_PATH="$coin_save_PKG_CONFIG_PATH"
     29050    export PKG_CONFIG_PATH
     29051
     29052  else
     29053    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     29054echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     29055
     29056echo "$as_me:$LINENO: checking for COIN-OR package Blas (fallback)" >&5
     29057echo $ECHO_N "checking for COIN-OR package Blas (fallback)... $ECHO_C" >&6
     29058
     29059coin_has_blas=notGiven
     29060BLAS_LIBS=
     29061BLAS_LIBS_INSTALLED=
     29062BLAS_CFLAGS=
     29063BLAS_CFLAGS_INSTALLED=
     29064BLAS_DATA=
     29065BLAS_DATA_INSTALLED=
     29066
     29067# initial list of dependencies is "coinblas", but we need to filter out version number specifications (= x, <= x, >= x)
     29068projtoprocess="coinblas"
     29069
     29070# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     29071# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     29072# the latter we also do with .pc files corresponding to the installed projects, which will be needed to setup Makefiles for examples
     29073# also, we setup the DATA variable
     29074allproj=""
     29075allpcfiles=""
     29076allpcifiles=""
     29077while test "x$projtoprocess" != x ; do
     29078
     29079  for proj in $projtoprocess ; do
     29080    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     29081    pcfile=""
     29082    save_IFS="$IFS"
     29083    IFS=":"
     29084    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     29085      # the base directory configure should have setup coin_subdirs.txt in a way that it does not contain projects that should be skipped, so we do not need to test this here again
     29086      if test -r "$dir/${proj}-uninstalled.pc" ; then
     29087        pcfile="$dir/$proj-uninstalled.pc"
     29088        if test -r "$dir/${proj}.pc" ; then
     29089          pcifile="$dir/${proj}.pc"
     29090        else
     29091          { echo "$as_me:$LINENO: WARNING: Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples." >&5
     29092echo "$as_me: WARNING: Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples." >&2;}
     29093          pcifile=
     29094        fi
     29095        break
     29096      fi
     29097    done
     29098    IFS="$save_IFS"
     29099
     29100    if test "x$pcfile" != x ; then
     29101      # read dependencies from $pcfile and filter it
     29102      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     29103
     29104      # add projrequires to the front of the list of projects that have to be processed next
     29105      # at the same time, remove $proj from this list
     29106      projtoprocess=${projtoprocess/$proj/$projrequires}
     29107
     29108      # read DATA from $pcfile, if _DATA is still empty
     29109      if test "x$BLAS_DATA" = x ; then
     29110        projdatadir=
     29111        pcfilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcfile`
     29112        eval `sh -c "$pcfilemod"`
     29113        BLAS_DATA="$projdatadir"
     29114      fi
     29115
     29116      allproj="$allproj $proj"
     29117      allpcfiles="$pcfile:$allpcfiles"
     29118
     29119    else
     29120      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     29121echo "${ECHO_T}no, dependency $proj not available" >&6
     29122      allproj=fail
     29123      break 2
     29124    fi
     29125
     29126    if test "x$pcifile" != x ; then
     29127      allpcifiles="$pcifile:$allpcifiles"
     29128
     29129      # read DATA_INSTALLED from $pcifile, if _DATA_INSTALLED is still empty
     29130      if test "x$BLAS_DATA_INSTALLED" = x ; then
     29131        projdatadir=
     29132        pcifilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcifile`
     29133        eval `sh -c "$pcifilemod"`
     29134        if test "${CYGPATH_W}" != "echo"; then
     29135          projdatadir="\`\$(CYGPATH_W) ${projdatadir} | sed -e 's/\\\\\\\\/\\\\\\\\\\\\\\\\/g'\`"
     29136        fi
     29137        BLAS_DATA_INSTALLED="$projdatadir"
     29138      fi
     29139
     29140    fi
     29141
     29142    break
     29143  done
     29144
     29145  # remove spaces on begin of $projtoprocess
     29146  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     29147
     29148done
     29149
     29150if test "$allproj" != fail ; then
     29151
     29152  # now go through the list of .pc files and assemble compiler and linker flags
     29153  # important is here to obey the reverse order that has been setup before,
     29154  # since then libraries that are required by several others should be after these other libraries
     29155  pcfilesprocessed=""
     29156
     29157  save_IFS="$IFS"
     29158  IFS=":"
     29159  for pcfile in $allpcfiles ; do
     29160
     29161    # if $pcfile has been processed already, skip this round
     29162    if test "x$pcfilesprocessed" != x ; then
     29163      for pcfiledone in $pcfilesprocessed ; do
     29164        if test "$pcfiledone" = "$pcfile" ; then
     29165          continue 2
     29166        fi
     29167      done
     29168    fi
     29169
     29170    # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags:
     29171    #   replace "Libs:" by "echo projlibs="
     29172    #   replace "Cflags:" by "echo projcflags="
     29173    #   remove every line starting with <some word>:
     29174    pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`
     29175
     29176    # set projcflags and projlibs variables by running $pcfilemod
     29177    projcflags=
     29178    projlibs=
     29179    eval `sh -c "$pcfilemod"`
     29180
     29181    # add CYGPATH_W cludge into include flags and set CFLAGS variable
     29182    if test "${CYGPATH_W}" != "echo"; then
     29183      projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     29184    fi
     29185    BLAS_CFLAGS="$projcflags $BLAS_CFLAGS"
     29186
     29187    # set LIBS variable
     29188    BLAS_LIBS="$projlibs $BLAS_LIBS"
     29189
     29190    # remember that we have processed $pcfile
     29191    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     29192
     29193  done
     29194  IFS="$save_IFS"
     29195
     29196
     29197  # now go through the list of .pc files for installed projects and assemble compiler and linker flags
     29198  # important is here again to obey the reverse order that has been setup before,
     29199  # since then libraries that are required by several others should be after these other libraries
     29200  pcfilesprocessed=""
     29201
     29202  save_IFS="$IFS"
     29203  IFS=":"
     29204  for pcfile in $allpcifiles ; do
     29205
     29206    # if $pcfile has been processed already, skip this round
     29207    if test "x$pcfilesprocessed" != x ; then
     29208      for pcfiledone in $pcfilesprocessed ; do
     29209        if test "$pcfiledone" = "$pcfile" ; then
     29210          continue 2
     29211        fi
     29212      done
     29213    fi
     29214
     29215    # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags:
     29216    #   replace "Libs:" by "echo projlibs="
     29217    #   replace "Cflags:" by "echo projcflags="
     29218    #   remove every line starting with <some word>:
     29219    pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`
     29220
     29221    # set projcflags and projlibs variables by running $pcfilemod
     29222    projcflags=
     29223    projlibs=
     29224    eval `sh -c "$pcfilemod"`
     29225
     29226    # add CYGPATH_W cludge into include flags and set CFLAGS variable
     29227    if test "${CYGPATH_W}" != "echo"; then
     29228      projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     29229    fi
     29230    BLAS_CFLAGS_INSTALLED="$projcflags $BLAS_CFLAGS_INSTALLED"
     29231
     29232    # set LIBS variable
     29233    BLAS_LIBS_INSTALLED="$projlibs $BLAS_LIBS_INSTALLED"
     29234
     29235    # remember that we have processed $pcfile
     29236    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     29237
     29238  done
     29239  IFS="$save_IFS"
     29240
     29241
     29242  # finish up
     29243  coin_has_blas=yes
     29244  echo "$as_me:$LINENO: result: yes" >&5
     29245echo "${ECHO_T}yes" >&6
     29246
     29247cat >>confdefs.h <<\_ACEOF
     29248#define COIN_HAS_BLAS 1
     29249_ACEOF
     29250
     29251
     29252  # adjust linker flags for (i)cl compiler
     29253  # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl),
     29254  # for the LIBS_INSTALLED, we replace everything of the form "/somepath/" by "`$(CYGPATH_W) /somepath/`",
     29255  #    everything of the form "-Lpath" by "/libpath:`$(CYGPATH_W) path`, and
     29256  #    everything of the form "-lname" by "libname.lib"
     29257  if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ;
     29258  then
     29259    BLAS_LIBS=`echo " $BLAS_LIBS " | sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g'`
     29260    BLAS_LIBS_INSTALLED=`echo " $BLAS_LIBS_INSTALLED" | sed -e 's/ \(\/[^ ]*\/\)/ \`$(CYGPATH_W) \1\`/g' -e 's/ -L\([^ ]*\)/ \/libpath:\`$(CYGPATH_W) \1\`/g' -e 's/ -l\([^ ]*\)/ lib\1.lib/g'`
     29261  fi
     29262
     29263
     29264    CLPLIB_PCREQUIRES="coinblas $CLPLIB_PCREQUIRES"
     29265    CLPLIB_CFLAGS="$BLAS_CFLAGS $CLPLIB_CFLAGS"
     29266    CLPLIB_LIBS="$BLAS_LIBS $CLPLIB_LIBS"
     29267    CLPLIB_CFLAGS_INSTALLED="$BLAS_CFLAGS_INSTALLED $CLPLIB_CFLAGS_INSTALLED"
     29268    CLPLIB_LIBS_INSTALLED="$BLAS_LIBS_INSTALLED $CLPLIB_LIBS_INSTALLED"
     29269
     29270
     29271fi
     29272
     29273
     29274
     29275if test $coin_has_blas != notGiven &&
     29276                test $coin_has_blas != skipping; then
     29277  COIN_HAS_BLAS_TRUE=
     29278  COIN_HAS_BLAS_FALSE='#'
     29279else
     29280  COIN_HAS_BLAS_TRUE='#'
     29281  COIN_HAS_BLAS_FALSE=
     29282fi
     29283
     29284
     29285
     29286  fi
     29287
     29288else
     29289  echo "$as_me:$LINENO: result: $coin_has_blas" >&5
     29290echo "${ECHO_T}$coin_has_blas" >&6
     29291fi
     29292
     29293if test $coin_has_blas != skipping &&
     29294   test $coin_has_blas != notGiven ; then
     29295
     29296cat >>confdefs.h <<\_ACEOF
     29297#define COIN_HAS_BLAS 1
     29298_ACEOF
     29299
     29300
     29301  # Check whether --enable-interpackage-dependencies or --disable-interpackage-dependencies was given.
     29302if test "${enable_interpackage_dependencies+set}" = set; then
     29303  enableval="$enable_interpackage_dependencies"
     29304
     29305else
     29306  enable_interpackage_dependencies=yes
     29307fi;
     29308
     29309  if test $enable_interpackage_dependencies = yes ; then
     29310     # construct dependencies variables from LIBS variables
     29311     # we add an extra space in LIBS so we can substitute out everything starting with " -"
     29312     # remove everything of the form -framework xxx as used on Mac and mklxxx as used on Windows
     29313     # then remove everything of the form -xxx
     29314     # also remove everything of the form `xxx`yyy (may have been added for cygwin/cl)
     29315     BLAS_DEPENDENCIES=`echo " $BLAS_LIBS" | sed -e 's/ mkl[^ ]*//g' -e 's/ -framework  *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g'`
     29316
     29317       CLPLIB_DEPENDENCIES=`echo " $CLPLIB_LIBS " | sed -e 's/ mkl[^ ]*//g' -e 's/ -framework  *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g'`
     29318
     29319  fi
     29320
     29321  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     29322    if test -n "$BLAS_CFLAGS" ; then
     29323      { echo "$as_me:$LINENO: Blas CFLAGS are $BLAS_CFLAGS" >&5
     29324echo "$as_me: Blas CFLAGS are $BLAS_CFLAGS" >&6;}
     29325    fi
     29326    if test -n "$BLAS_LIBS" ; then
     29327      { echo "$as_me:$LINENO: Blas LIBS   are $BLAS_LIBS" >&5
     29328echo "$as_me: Blas LIBS   are $BLAS_LIBS" >&6;}
     29329    fi
     29330    if test -n "$BLAS_DEPENDENCIES" ; then
     29331      { echo "$as_me:$LINENO: Blas DEPENDENCIES are $BLAS_DEPENDENCIES" >&5
     29332echo "$as_me: Blas DEPENDENCIES are $BLAS_DEPENDENCIES" >&6;}
     29333    fi
     29334    if test -n "$BLAS_DATA" ; then
     29335      { echo "$as_me:$LINENO: Blas DATA   is  $BLAS_DATA" >&5
     29336echo "$as_me: Blas DATA   is  $BLAS_DATA" >&6;}
     29337    fi
     29338    if test -n "$BLAS_CFLAGS" ; then
     29339      { echo "$as_me:$LINENO: Blas CFLAGS are $BLAS_CFLAGS" >&5
     29340echo "$as_me: Blas CFLAGS are $BLAS_CFLAGS" >&6;}
     29341    fi
     29342
     29343      { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
     29344echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
     29345      { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
     29346echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
     29347      { echo "$as_me:$LINENO: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&5
     29348echo "$as_me: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&6;}
     29349
     29350  fi
     29351fi
     29352
     29353# Define the Makefile conditional
     29354
     29355
     29356if test $coin_has_blas != notGiven &&
     29357                test $coin_has_blas != skipping; then
     29358  COIN_HAS_BLAS_TRUE=
     29359  COIN_HAS_BLAS_FALSE='#'
     29360else
     29361  COIN_HAS_BLAS_TRUE='#'
     29362  COIN_HAS_BLAS_FALSE=
     29363fi
     29364
     29365
     29366
     29367
     29368elif test "x$use_blas" != x && test "$use_blas" != no; then
     29369  coin_has_blas=yes
     29370
     29371
     29372if test 0 = 0; then
     29373  COIN_HAS_BLAS_TRUE=
     29374  COIN_HAS_BLAS_FALSE='#'
     29375else
     29376  COIN_HAS_BLAS_TRUE='#'
     29377  COIN_HAS_BLAS_FALSE=
     29378fi
     29379
     29380
     29381cat >>confdefs.h <<\_ACEOF
     29382#define COIN_HAS_BLAS 1
     29383_ACEOF
     29384
     29385  BLAS_LIBS="$use_blas"
     29386  BLAS_CFLAGS=
     29387  BLAS_DATA=
     29388
     29389
     29390
     29391
     29392    CLPLIB_PCLIBS="$BLAS_LIBS $CLPLIB_PCLIBS"
     29393    CLPLIB_LIBS="$BLAS_LIBS $CLPLIB_LIBS"
     29394    CLPLIB_LIBS_INSTALLED="$BLAS_LIBS $CLPLIB_LIBS_INSTALLED"
     29395
     29396
     29397else
     29398  coin_has_blas=no
     29399
     29400
     29401if test 0 = 1; then
     29402  COIN_HAS_BLAS_TRUE=
     29403  COIN_HAS_BLAS_FALSE='#'
     29404else
     29405  COIN_HAS_BLAS_TRUE='#'
     29406  COIN_HAS_BLAS_FALSE=
     29407fi
     29408
     29409fi
     29410
     29411
     29412
     29413
     29414
     29415
     29416
     29417
     29418
     29419  coin_save_LIBS="$LIBS"
     29420  LIBS="$LIBS $use_wsmp $BLAS_LIBS"
     29421  ac_ext=f
     29422ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     29423ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     29424ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     29425
     29426  echo "$as_me:$LINENO: checking whether user-supplied WSMP library \"$use_wsmp\" works" >&5
     29427echo $ECHO_N "checking whether user-supplied WSMP library \"$use_wsmp\" works... $ECHO_C" >&6
     29428  cat >conftest.$ac_ext <<_ACEOF
     29429      program main
     29430      call WSSMP()
     29431      end
     29432_ACEOF
     29433rm -f conftest.$ac_objext conftest$ac_exeext
     29434if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
     29435  (eval $ac_link) 2>conftest.er1
     29436  ac_status=$?
     29437  grep -v '^ *+' conftest.er1 >conftest.err
     29438  rm -f conftest.er1
     29439  cat conftest.err >&5
     29440  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     29441  (exit $ac_status); } &&
     29442         { ac_try='test -z "$ac_f77_werror_flag"
     29443                         || test ! -s conftest.err'
     29444  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     29445  (eval $ac_try) 2>&5
     29446  ac_status=$?
     29447  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     29448  (exit $ac_status); }; } &&
     29449         { ac_try='test -s conftest$ac_exeext'
     29450  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
     29451  (eval $ac_try) 2>&5
     29452  ac_status=$?
     29453  echo "$as_me:$LINENO: \$? = $ac_status" >&5
     29454  (exit $ac_status); }; }; then
     29455  echo "$as_me:$LINENO: result: yes" >&5
     29456echo "${ECHO_T}yes" >&6
     29457else
     29458  echo "$as_me: failed program was:" >&5
     29459sed 's/^/| /' conftest.$ac_ext >&5
     29460
     29461echo "$as_me:$LINENO: result: no" >&5
     29462echo "${ECHO_T}no" >&6
     29463               { { echo "$as_me:$LINENO: error: WSMP library $use_wsmp does not seem to work" >&5
    2318329464echo "$as_me: error: WSMP library $use_wsmp does not seem to work" >&2;}
    2318429465   { (exit 1); exit 1; }; }
    23185   fi
     29466fi
     29467rm -f conftest.err conftest.$ac_objext \
     29468      conftest$ac_exeext conftest.$ac_ext
     29469  ac_ext=c
     29470ac_cpp='$CPP $CPPFLAGS'
     29471ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     29472ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     29473ac_compiler_gnu=$ac_cv_c_compiler_gnu
     29474
     29475  LIBS="$coin_save_LIBS"
    2318629476
    2318729477
    2318829478cat >>confdefs.h <<_ACEOF
    23189 #define WSSMP_BARRIER $defval
     29479#define COIN_HAS_WSMP 1
    2319029480_ACEOF
    2319129481
    23192 fi
     29482
     29483  CLPLIB_LIBS="$use_wsmp $CLPLIB_LIBS"
     29484  CLPLIB_LIBS_INSTALLED="$use_wsmp $CLPLIB_LIBS_INSTALLED"
     29485  CLPLIB_PCLIBS="$use_wsmp $CLPLIB_PCLIBS"
     29486fi
     29487
     29488
     29489if test "$use_wsmp" != no; then
     29490  COIN_HAS_WSMP_TRUE=
     29491  COIN_HAS_WSMP_FALSE='#'
     29492else
     29493  COIN_HAS_WSMP_TRUE='#'
     29494  COIN_HAS_WSMP_FALSE=
     29495fi
     29496
    2319329497
    2319429498#############################################################################
     
    2330629610   builtin and then its argument prototype would still apply.  */
    2330729611char tputs ();
     29612#ifdef F77_DUMMY_MAIN
     29613
     29614#  ifdef __cplusplus
     29615     extern "C"
     29616#  endif
     29617   int F77_DUMMY_MAIN() { return 1; }
     29618
     29619#endif
    2330829620int
    2330929621main ()
     
    2336129673   builtin and then its argument prototype would still apply.  */
    2336229674char tputs ();
     29675#ifdef F77_DUMMY_MAIN
     29676
     29677#  ifdef __cplusplus
     29678     extern "C"
     29679#  endif
     29680   int F77_DUMMY_MAIN() { return 1; }
     29681
     29682#endif
    2336329683int
    2336429684main ()
     
    2343829758   builtin and then its argument prototype would still apply.  */
    2343929759char readline ();
     29760#ifdef F77_DUMMY_MAIN
     29761
     29762#  ifdef __cplusplus
     29763     extern "C"
     29764#  endif
     29765   int F77_DUMMY_MAIN() { return 1; }
     29766
     29767#endif
    2344029768int
    2344129769main ()
     
    2402130349Usually this means the macro was only invoked conditionally." >&5
    2402230350echo "$as_me: error: conditional \"COIN_HAS_NETLIB\" was never defined.
     30351Usually this means the macro was only invoked conditionally." >&2;}
     30352   { (exit 1); exit 1; }; }
     30353fi
     30354if test -z "${COIN_HAS_AMD_TRUE}" && test -z "${COIN_HAS_AMD_FALSE}"; then
     30355  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_AMD\" was never defined.
     30356Usually this means the macro was only invoked conditionally." >&5
     30357echo "$as_me: error: conditional \"COIN_HAS_AMD\" was never defined.
     30358Usually this means the macro was only invoked conditionally." >&2;}
     30359   { (exit 1); exit 1; }; }
     30360fi
     30361if test -z "${COIN_HAS_CHOLMOD_TRUE}" && test -z "${COIN_HAS_CHOLMOD_FALSE}"; then
     30362  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_CHOLMOD\" was never defined.
     30363Usually this means the macro was only invoked conditionally." >&5
     30364echo "$as_me: error: conditional \"COIN_HAS_CHOLMOD\" was never defined.
     30365Usually this means the macro was only invoked conditionally." >&2;}
     30366   { (exit 1); exit 1; }; }
     30367fi
     30368if test -z "${COIN_HAS_GLPK_TRUE}" && test -z "${COIN_HAS_GLPK_FALSE}"; then
     30369  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_GLPK\" was never defined.
     30370Usually this means the macro was only invoked conditionally." >&5
     30371echo "$as_me: error: conditional \"COIN_HAS_GLPK\" was never defined.
     30372Usually this means the macro was only invoked conditionally." >&2;}
     30373   { (exit 1); exit 1; }; }
     30374fi
     30375if test -z "${COIN_HAS_GLPK_TRUE}" && test -z "${COIN_HAS_GLPK_FALSE}"; then
     30376  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_GLPK\" was never defined.
     30377Usually this means the macro was only invoked conditionally." >&5
     30378echo "$as_me: error: conditional \"COIN_HAS_GLPK\" was never defined.
     30379Usually this means the macro was only invoked conditionally." >&2;}
     30380   { (exit 1); exit 1; }; }
     30381fi
     30382if test -z "${COIN_HAS_GLPK_TRUE}" && test -z "${COIN_HAS_GLPK_FALSE}"; then
     30383  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_GLPK\" was never defined.
     30384Usually this means the macro was only invoked conditionally." >&5
     30385echo "$as_me: error: conditional \"COIN_HAS_GLPK\" was never defined.
     30386Usually this means the macro was only invoked conditionally." >&2;}
     30387   { (exit 1); exit 1; }; }
     30388fi
     30389if test -z "${COIN_HAS_MUMPS_TRUE}" && test -z "${COIN_HAS_MUMPS_FALSE}"; then
     30390  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_MUMPS\" was never defined.
     30391Usually this means the macro was only invoked conditionally." >&5
     30392echo "$as_me: error: conditional \"COIN_HAS_MUMPS\" was never defined.
     30393Usually this means the macro was only invoked conditionally." >&2;}
     30394   { (exit 1); exit 1; }; }
     30395fi
     30396if test -z "${COIN_HAS_MUMPS_TRUE}" && test -z "${COIN_HAS_MUMPS_FALSE}"; then
     30397  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_MUMPS\" was never defined.
     30398Usually this means the macro was only invoked conditionally." >&5
     30399echo "$as_me: error: conditional \"COIN_HAS_MUMPS\" was never defined.
     30400Usually this means the macro was only invoked conditionally." >&2;}
     30401   { (exit 1); exit 1; }; }
     30402fi
     30403if test -z "${COIN_HAS_BLAS_TRUE}" && test -z "${COIN_HAS_BLAS_FALSE}"; then
     30404  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_BLAS\" was never defined.
     30405Usually this means the macro was only invoked conditionally." >&5
     30406echo "$as_me: error: conditional \"COIN_HAS_BLAS\" was never defined.
     30407Usually this means the macro was only invoked conditionally." >&2;}
     30408   { (exit 1); exit 1; }; }
     30409fi
     30410if test -z "${COIN_HAS_BLAS_TRUE}" && test -z "${COIN_HAS_BLAS_FALSE}"; then
     30411  { { echo "$as_me:$LINENO: error: conditional \"COIN_HAS_BLAS\" was never defined.
     30412Usually this means the macro was only invoked conditionally." >&5
     30413