Changeset 1696 for trunk/Clp


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

for integer problems with large values

Location:
trunk/Clp
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/configure

    </
    r1695 r1696  
    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 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'
     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 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
    1000 ac_env_ADD_FFLAGS_set=${ADD_FFLAGS+set}
    1001 ac_env_ADD_FFLAGS_value=$ADD_FFLAGS
    1002 ac_cv_env_ADD_FFLAGS_set=${ADD_FFLAGS+set}
    1003 ac_cv_env_ADD_FFLAGS_value=$ADD_FFLAGS
    1004 ac_env_DBG_FFLAGS_set=${DBG_FFLAGS+set}
    1005 ac_env_DBG_FFLAGS_value=$DBG_FFLAGS
    1006 ac_cv_env_DBG_FFLAGS_set=${DBG_FFLAGS+set}
    1007 ac_cv_env_DBG_FFLAGS_value=$DBG_FFLAGS
    1008 ac_env_OPT_FFLAGS_set=${OPT_FFLAGS+set}
    1009 ac_env_OPT_FFLAGS_value=$OPT_FFLAGS
    1010 ac_cv_env_OPT_FFLAGS_set=${OPT_FFLAGS+set}
    1011 ac_cv_env_OPT_FFLAGS_value=$OPT_FFLAGS
    1012 ac_env_MPIF77_set=${MPIF77+set}
    1013 ac_env_MPIF77_value=$MPIF77
    1014 ac_cv_env_MPIF77_set=${MPIF77+set}
    1015 ac_cv_env_MPIF77_value=$MPIF77
    10161000
    10171001#
     
    11171101                          whether to deduce Makefile dependencies from package
    11181102                          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
    11241103  --enable-gnu-packages   compile with GNU packages (disabled by default)
    11251104
     
    11551134  --with-netlib-incdir directory with header files for using package Netlib
    11561135  --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
    11671136  --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
    11741137  --with-dot              use dot (from graphviz) when creating documentation
    11751138                          with doxygen if available; --without-dot to disable
     
    12021165  FFLAGS      Fortran 77 compiler flags
    12031166  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
    12081167
    12091168Use these variables to override the choices made by `configure' or to help
     
    17631722coin_projectdir=yes
    17641723
    1765 # Set the project's version numbers
     1724# Set the project's version number
    17661725
    17671726
    17681727cat >>confdefs.h <<_ACEOF
    17691728#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 
    1780 cat >>confdefs.h <<_ACEOF
    1781 #define CLP_VERSION_MAJOR $coin_majorver
    1782 _ACEOF
    1783 
    1784 
    1785 cat >>confdefs.h <<_ACEOF
    1786 #define CLP_VERSION_MINOR $coin_minorver
    1787 _ACEOF
    1788 
    1789 
    1790 cat >>confdefs.h <<_ACEOF
    1791 #define CLP_VERSION_RELEASE $coin_releasever
    17921729_ACEOF
    17931730
     
    28832820        coin_add_cflags="-pipe"
    28842821        coin_dbg_cflags="-g"
    2885         coin_warn_cflags="-Wimplicit -Wparentheses -Wsequence-point -Wreturn-type -Wcast-qual -Wall -Wno-unknown-pragmas -Wno-long-long"
     2822        coin_warn_cflags="-Wimplicit -Wparentheses -Wsequence-point -Wreturn-type -Wcast-qual -Wall -Wno-unknown-pragmas"
    28862823        case $build in
    28872824          *-darwin*)
     
    38103747        coin_add_cxxflags="-pipe"
    38113748        coin_dbg_cxxflags="-g"
    3812         coin_warn_cxxflags="-Wimplicit -Wparentheses -Wreturn-type -Wcast-qual -Wall -Wpointer-arith -Wwrite-strings -Wconversion -Wno-unknown-pragmas -Wno-long-long"
     3749        coin_warn_cxxflags="-Wimplicit -Wparentheses -Wreturn-type -Wcast-qual -Wall -Wpointer-arith -Wwrite-strings -Wconversion -Wno-unknown-pragmas"
    38133750        case $build in
    38143751          *-darwin*)
     
    59785915*-*-irix6*)
    59795916  # Find out which ABI we are using.
    5980   echo '#line 5980 "configure"' > conftest.$ac_ext
     5917  echo '#line 5917 "configure"' > conftest.$ac_ext
    59815918  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
    59825919  (eval $ac_compile) 2>&5
     
    71127049
    71137050# Provide some information about the compiler.
    7114 echo "$as_me:7114:" \
     7051echo "$as_me:7051:" \
    71157052     "checking for Fortran 77 compiler version" >&5
    71167053ac_compiler=`set X $ac_compile; echo $2`
     
    81798116   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    81808117   -e 's:$: $lt_compiler_flag:'`
    8181    (eval echo "\"\$as_me:8181: $lt_compile\"" >&5)
     8118   (eval echo "\"\$as_me:8118: $lt_compile\"" >&5)
    81828119   (eval "$lt_compile" 2>conftest.err)
    81838120   ac_status=$?
    81848121   cat conftest.err >&5
    8185    echo "$as_me:8185: \$? = $ac_status" >&5
     8122   echo "$as_me:8122: \$? = $ac_status" >&5
    81868123   if (exit $ac_status) && test -s "$ac_outfile"; then
    81878124     # The compiler can only warn and ignore the option if not recognized
     
    84478384   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    84488385   -e 's:$: $lt_compiler_flag:'`
    8449    (eval echo "\"\$as_me:8449: $lt_compile\"" >&5)
     8386   (eval echo "\"\$as_me:8386: $lt_compile\"" >&5)
    84508387   (eval "$lt_compile" 2>conftest.err)
    84518388   ac_status=$?
    84528389   cat conftest.err >&5
    8453    echo "$as_me:8453: \$? = $ac_status" >&5
     8390   echo "$as_me:8390: \$? = $ac_status" >&5
    84548391   if (exit $ac_status) && test -s "$ac_outfile"; then
    84558392     # The compiler can only warn and ignore the option if not recognized
     
    85518488   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    85528489   -e 's:$: $lt_compiler_flag:'`
    8553    (eval echo "\"\$as_me:8553: $lt_compile\"" >&5)
     8490   (eval echo "\"\$as_me:8490: $lt_compile\"" >&5)
    85548491   (eval "$lt_compile" 2>out/conftest.err)
    85558492   ac_status=$?
    85568493   cat out/conftest.err >&5
    8557    echo "$as_me:8557: \$? = $ac_status" >&5
     8494   echo "$as_me:8494: \$? = $ac_status" >&5
    85588495   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    85598496   then
     
    1089610833  lt_status=$lt_dlunknown
    1089710834  cat > conftest.$ac_ext <<EOF
    10898 #line 10898 "configure"
     10835#line 10835 "configure"
    1089910836#include "confdefs.h"
    1090010837
     
    1099610933  lt_status=$lt_dlunknown
    1099710934  cat > conftest.$ac_ext <<EOF
    10998 #line 10998 "configure"
     10935#line 10935 "configure"
    1099910936#include "confdefs.h"
    1100010937
     
    1334013277   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1334113278   -e 's:$: $lt_compiler_flag:'`
    13342    (eval echo "\"\$as_me:13342: $lt_compile\"" >&5)
     13279   (eval echo "\"\$as_me:13279: $lt_compile\"" >&5)
    1334313280   (eval "$lt_compile" 2>conftest.err)
    1334413281   ac_status=$?
    1334513282   cat conftest.err >&5
    13346    echo "$as_me:13346: \$? = $ac_status" >&5
     13283   echo "$as_me:13283: \$? = $ac_status" >&5
    1334713284   if (exit $ac_status) && test -s "$ac_outfile"; then
    1334813285     # The compiler can only warn and ignore the option if not recognized
     
    1344413381   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1344513382   -e 's:$: $lt_compiler_flag:'`
    13446    (eval echo "\"\$as_me:13446: $lt_compile\"" >&5)
     13383   (eval echo "\"\$as_me:13383: $lt_compile\"" >&5)
    1344713384   (eval "$lt_compile" 2>out/conftest.err)
    1344813385   ac_status=$?
    1344913386   cat out/conftest.err >&5
    13450    echo "$as_me:13450: \$? = $ac_status" >&5
     13387   echo "$as_me:13387: \$? = $ac_status" >&5
    1345113388   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    1345213389   then
     
    1501414951   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1501514952   -e 's:$: $lt_compiler_flag:'`
    15016    (eval echo "\"\$as_me:15016: $lt_compile\"" >&5)
     14953   (eval echo "\"\$as_me:14953: $lt_compile\"" >&5)
    1501714954   (eval "$lt_compile" 2>conftest.err)
    1501814955   ac_status=$?
    1501914956   cat conftest.err >&5
    15020    echo "$as_me:15020: \$? = $ac_status" >&5
     14957   echo "$as_me:14957: \$? = $ac_status" >&5
    1502114958   if (exit $ac_status) && test -s "$ac_outfile"; then
    1502214959     # The compiler can only warn and ignore the option if not recognized
     
    1511815055   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1511915056   -e 's:$: $lt_compiler_flag:'`
    15120    (eval echo "\"\$as_me:15120: $lt_compile\"" >&5)
     15057   (eval echo "\"\$as_me:15057: $lt_compile\"" >&5)
    1512115058   (eval "$lt_compile" 2>out/conftest.err)
    1512215059   ac_status=$?
    1512315060   cat out/conftest.err >&5
    15124    echo "$as_me:15124: \$? = $ac_status" >&5
     15061   echo "$as_me:15061: \$? = $ac_status" >&5
    1512515062   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    1512615063   then
     
    1732517262   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1732617263   -e 's:$: $lt_compiler_flag:'`
    17327    (eval echo "\"\$as_me:17327: $lt_compile\"" >&5)
     17264   (eval echo "\"\$as_me:17264: $lt_compile\"" >&5)
    1732817265   (eval "$lt_compile" 2>conftest.err)
    1732917266   ac_status=$?
    1733017267   cat conftest.err >&5
    17331    echo "$as_me:17331: \$? = $ac_status" >&5
     17268   echo "$as_me:17268: \$? = $ac_status" >&5
    1733217269   if (exit $ac_status) && test -s "$ac_outfile"; then
    1733317270     # The compiler can only warn and ignore the option if not recognized
     
    1759317530   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1759417531   -e 's:$: $lt_compiler_flag:'`
    17595    (eval echo "\"\$as_me:17595: $lt_compile\"" >&5)
     17532   (eval echo "\"\$as_me:17532: $lt_compile\"" >&5)
    1759617533   (eval "$lt_compile" 2>conftest.err)
    1759717534   ac_status=$?
    1759817535   cat conftest.err >&5
    17599    echo "$as_me:17599: \$? = $ac_status" >&5
     17536   echo "$as_me:17536: \$? = $ac_status" >&5
    1760017537   if (exit $ac_status) && test -s "$ac_outfile"; then
    1760117538     # The compiler can only warn and ignore the option if not recognized
     
    1769717634   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    1769817635   -e 's:$: $lt_compiler_flag:'`
    17699    (eval echo "\"\$as_me:17699: $lt_compile\"" >&5)
     17636   (eval echo "\"\$as_me:17636: $lt_compile\"" >&5)
    1770017637   (eval "$lt_compile" 2>out/conftest.err)
    1770117638   ac_status=$?
    1770217639   cat out/conftest.err >&5
    17703    echo "$as_me:17703: \$? = $ac_status" >&5
     17640   echo "$as_me:17640: \$? = $ac_status" >&5
    1770417641   if (exit $ac_status) && test -s out/conftest2.$ac_objext
    1770517642   then
     
    2312323060#############################################################################
    2312423061
    23125 # AMD from UFL
    23126 
    23127   echo "$as_me:$LINENO: checking if user provides library for AMD" >&5
    23128 echo $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.
    23134 if test "${with_amd_incdir+set}" = set; then
    23135   withval="$with_amd_incdir"
    23136   AMDINCDIR=`cd $withval; pwd`
     23062# WSMP
     23063
     23064# Check whether --with-wsmp or --without-wsmp was given.
     23065if test "${with_wsmp+set}" = set; then
     23066  withval="$with_wsmp"
     23067  use_wsmp=$withval
     23068else
     23069  use_wsmp=no
    2313723070fi;
    2313823071
    23139 # Check for library directory
    23140 
    23141 
    23142 # Check whether --with-amd-lib or --without-amd-lib was given.
    23143 if test "${with_amd_lib+set}" = set; then
    23144   withval="$with_amd_lib"
    23145   AMDLIB=$withval
    23146 fi;
    23147 
    23148 # Switch to disable library check if requested
    23149 
    23150   # Check whether --enable-amd-libcheck or --disable-amd-libcheck was given.
    23151 if test "${enable_amd_libcheck+set}" = set; then
    23152   enableval="$enable_amd_libcheck"
    23153   amd_libcheck=$enableval
    23154 else
    23155   amd_libcheck=yes
    23156 fi;
    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
    23164 echo "$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
    23169 echo "${ECHO_T}yes" >&6
    23170   else
    23171     coin_has_amd=false
    23172     echo "$as_me:$LINENO: result: no" >&5
    23173 echo "${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   :
    23186 else
    23187   { { echo "$as_me:$LINENO: error: Cannot find file amd.h in $AMDINCDIR" >&5
    23188 echo "$as_me: error: Cannot find file amd.h in $AMDINCDIR" >&2;}
    23189    { (exit 1); exit 1; }; }
    23190   :
    23191 fi
    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
    23206 ac_cpp='$CPP $CPPFLAGS'
    23207 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    23208 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    23209 ac_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
    23213 echo $ECHO_N "checking whether symbol $fnm is available with AMD... $ECHO_C" >&6
    23214              cat >conftest.$ac_ext <<_ACEOF
     23072if 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
     23078echo $ECHO_N "checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp_)... $ECHO_C" >&6
     23079  cat >conftest.$ac_ext <<_ACEOF
    2321523080/* confdefs.h.  */
    2321623081_ACEOF
     
    2322223087main ()
    2322323088{
    23224 $fnm()
     23089wssmp_()
    2322523090  ;
    2322623091  return 0;
     
    2325123116  echo "$as_me:$LINENO: result: yes" >&5
    2325223117echo "${ECHO_T}yes" >&6
    23253                   coin_AMD_link=yes
    23254                   break
     23118               defval=2
    2325523119else
    2325623120  echo "$as_me: failed program was:" >&5
     
    2326223126rm -f conftest.err conftest.$ac_objext \
    2326323127      conftest$ac_exeext conftest.$ac_ext
    23264            done
    23265            ac_ext=c
    23266 ac_cpp='$CPP $CPPFLAGS'
    23267 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    23268 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    23269 ac_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
    23274 echo "$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 
    23291 cat >>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 
    23304 if test $coin_has_amd = true; then
    23305   COIN_HAS_AMD_TRUE=
    23306   COIN_HAS_AMD_FALSE='#'
    23307 else
    23308   COIN_HAS_AMD_TRUE='#'
    23309   COIN_HAS_AMD_FALSE=
    23310 fi
    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
    23317 coin_save_LIBS="$LIBS"
    23318 LIBS="$LIBS $AMD_LIBS"
    23319 
    23320   echo "$as_me:$LINENO: checking if user provides library for CHOLMOD" >&5
    23321 echo $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.
    23327 if test "${with_cholmod_incdir+set}" = set; then
    23328   withval="$with_cholmod_incdir"
    23329   CHOLMODINCDIR=`cd $withval; pwd`
    23330 fi;
    23331 
    23332 # Check for library directory
    23333 
    23334 
    23335 # Check whether --with-cholmod-lib or --without-cholmod-lib was given.
    23336 if test "${with_cholmod_lib+set}" = set; then
    23337   withval="$with_cholmod_lib"
    23338   CHOLMODLIB=$withval
    23339 fi;
    23340 
    23341 # Switch to disable library check if requested
    23342 
    23343   # Check whether --enable-cholmod-libcheck or --disable-cholmod-libcheck was given.
    23344 if test "${enable_cholmod_libcheck+set}" = set; then
    23345   enableval="$enable_cholmod_libcheck"
    23346   cholmod_libcheck=$enableval
    23347 else
    23348   cholmod_libcheck=yes
    23349 fi;
    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
    23357 echo "$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
    23362 echo "${ECHO_T}yes" >&6
    23363   else
    23364     coin_has_cholmod=false
    23365     echo "$as_me:$LINENO: result: no" >&5
    23366 echo "${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   :
    23379 else
    23380   { { echo "$as_me:$LINENO: error: Cannot find file cholmod.h in $CHOLMODINCDIR" >&5
    23381 echo "$as_me: error: Cannot find file cholmod.h in $CHOLMODINCDIR" >&2;}
    23382    { (exit 1); exit 1; }; }
    23383   :
    23384 fi
    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
    23399 ac_cpp='$CPP $CPPFLAGS'
    23400 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    23401 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    23402 ac_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
    23406 echo $ECHO_N "checking whether symbol $fnm is available with CHOLMOD... $ECHO_C" >&6
    23407              cat >conftest.$ac_ext <<_ACEOF
     23128  if test "$defval" = ""; then
     23129    echo "$as_me:$LINENO: checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp)" >&5
     23130echo $ECHO_N "checking whether user-supplied WSMP library \"$use_wsmp\" works (symbol wssmp)... $ECHO_C" >&6
     23131    cat >conftest.$ac_ext <<_ACEOF
    2340823132/* confdefs.h.  */
    2340923133_ACEOF
     
    2341523139main ()
    2341623140{
    23417 $fnm()
     23141wssmp()
    2341823142  ;
    2341923143  return 0;
     
    2344423168  echo "$as_me:$LINENO: result: yes" >&5
    2344523169echo "${ECHO_T}yes" >&6
    23446                   coin_CHOLMOD_link=yes
    23447                   break
     23170                 defval=3
    2344823171else
    2344923172  echo "$as_me: failed program was:" >&5
     
    2345223175echo "$as_me:$LINENO: result: no" >&5
    2345323176echo "${ECHO_T}no" >&6
    23454 fi
    23455 rm -f conftest.err conftest.$ac_objext \
    23456       conftest$ac_exeext conftest.$ac_ext
    23457            done
    23458            ac_ext=c
    23459 ac_cpp='$CPP $CPPFLAGS'
    23460 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    23461 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    23462 ac_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
    23467 echo "$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 
    23484 cat >>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 
    23497 if test $coin_has_cholmod = true; then
    23498   COIN_HAS_CHOLMOD_TRUE=
    23499   COIN_HAS_CHOLMOD_FALSE='#'
    23500 else
    23501   COIN_HAS_CHOLMOD_TRUE='#'
    23502   COIN_HAS_CHOLMOD_FALSE=
    23503 fi
    23504 
    23505 
    23506 LIBS="$coin_save_LIBS"
    23507 
    23508 # Glpk also brings AMD
    23509 if test $coin_has_cholmod = false -a $coin_has_amd = false ; then
    23510 
    23511 echo "$as_me:$LINENO: checking for COIN-OR package Glpk" >&5
    23512 echo $ECHO_N "checking for COIN-OR package Glpk... $ECHO_C" >&6
    23513 
    23514 coin_has_glpk=notGiven
    23515 
    23516 # check if user wants to skip package in any case
    23517 if 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
    23523 fi
    23524 
    23525 GLPK_LIBS=
    23526 GLPK_CFLAGS=
    23527 GLPK_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
    23546 if test $coin_has_glpk != skipping; then
    23547 
    23548 # Check whether --with-m4_tolower(Glpk)-lib or --without-m4_tolower(Glpk)-lib was given.
    23549 if 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 
    23567 fi;
    23568 fi
    23569 
    23570 if test $coin_has_glpk != skipping; then
    23571 
    23572 # Check whether --with-m4_tolower(Glpk)-incdir or --without-m4_tolower(Glpk)-incdir was given.
    23573 if 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 
    23588 fi;
    23589 fi
    23590 
    23591 if test $coin_has_glpk != skipping; then
    23592 
    23593 # Check whether --with-m4_tolower(Glpk)-datadir or --without-m4_tolower(Glpk)-datadir was given.
    23594 if 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 
    23607 fi;
    23608 fi
    23609 
    23610 if 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 
    23622 if 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
    23638 echo "${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
    23659 echo "${ECHO_T}not given: $GLPK_PKG_ERRORS" >&6
    23660 
    23661   fi
    23662 else
    23663   { { echo "$as_me:$LINENO: error: \"Cannot check for existance of module Glpk without pkg-config\"" >&5
    23664 echo "$as_me: error: \"Cannot check for existance of module Glpk without pkg-config\"" >&2;}
    23665    { (exit 1); exit 1; }; }
    23666 fi
    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
    23677 echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
    23678 
    23679 echo "$as_me:$LINENO: checking for COIN-OR package Glpk (fallback)" >&5
    23680 echo $ECHO_N "checking for COIN-OR package Glpk (fallback)... $ECHO_C" >&6
    23681 
    23682 coin_has_glpk=notGiven
    23683 GLPK_LIBS=
    23684 GLPK_LIBS_INSTALLED=
    23685 GLPK_CFLAGS=
    23686 GLPK_CFLAGS_INSTALLED=
    23687 GLPK_DATA=
    23688 GLPK_DATA_INSTALLED=
    23689 
    23690 # initial list of dependencies is "coinglpk >= 4.39", but we need to filter out version number specifications (= x, <= x, >= x)
    23691 projtoprocess="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
    23697 allproj=""
    23698 allpcfiles=""
    23699 allpcifiles=""
    23700 while 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
    23715 echo "$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
    23744 echo "${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 
    23771 done
    23772 
    23773 if 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
    23868 echo "${ECHO_T}yes" >&6
    23869 
    23870 cat >>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 
    23894 fi
    23895 
    23896 
    23897 
    23898 if test $coin_has_glpk != notGiven &&
    23899                 test $coin_has_glpk != skipping; then
    23900   COIN_HAS_GLPK_TRUE=
    23901   COIN_HAS_GLPK_FALSE='#'
    23902 else
    23903   COIN_HAS_GLPK_TRUE='#'
    23904   COIN_HAS_GLPK_FALSE=
    23905 fi
    23906 
    23907 
    23908 
    23909   fi
    23910 
    23911 else
    23912   echo "$as_me:$LINENO: result: $coin_has_glpk" >&5
    23913 echo "${ECHO_T}$coin_has_glpk" >&6
    23914 fi
    23915 
    23916 if test $coin_has_glpk != skipping &&
    23917    test $coin_has_glpk != notGiven ; then
    23918 
    23919 cat >>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.
    23925 if test "${enable_interpackage_dependencies+set}" = set; then
    23926   enableval="$enable_interpackage_dependencies"
    23927 
    23928 else
    23929   enable_interpackage_dependencies=yes
    23930 fi;
    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
    23947 echo "$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
    23951 echo "$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
    23955 echo "$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
    23959 echo "$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
    23963 echo "$as_me: Glpk CFLAGS are $GLPK_CFLAGS" >&6;}
    23964     fi
    23965 
    23966       { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
    23967 echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
    23968       { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
    23969 echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
    23970       { echo "$as_me:$LINENO: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&5
    23971 echo "$as_me: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&6;}
    23972 
    23973   fi
    23974 fi
    23975 
    23976 # Define the Makefile conditional
    23977 
    23978 
    23979 if test $coin_has_glpk != notGiven &&
    23980                 test $coin_has_glpk != skipping; then
    23981   COIN_HAS_GLPK_TRUE=
    23982   COIN_HAS_GLPK_FALSE='#'
    23983 else
    23984   COIN_HAS_GLPK_TRUE='#'
    23985   COIN_HAS_GLPK_FALSE=
    23986 fi
    23987 
    23988 
    23989 
    23990   if test $coin_has_glpk = yes ; then
    23991     { echo "$as_me:$LINENO: using AMD from GLPK package" >&5
    23992 echo "$as_me: using AMD from GLPK package" >&6;}
    23993 
    23994 cat >>confdefs.h <<\_ACEOF
    23995 #define COIN_HAS_AMD 1
    23996 _ACEOF
    23997 
    23998   fi
    23999 else
    24000   # for configure
    24001 
    24002 
    24003 if test 0 = 1; then
    24004   COIN_HAS_GLPK_TRUE=
    24005   COIN_HAS_GLPK_FALSE='#'
    24006 else
    24007   COIN_HAS_GLPK_TRUE='#'
    24008   COIN_HAS_GLPK_FALSE=
    24009 fi
    24010 
    24011 fi
    24012 
    24013 # MUMPS
    24014 
    24015 echo "$as_me:$LINENO: checking for COIN-OR package Mumps" >&5
    24016 echo $ECHO_N "checking for COIN-OR package Mumps... $ECHO_C" >&6
    24017 
    24018 coin_has_mumps=notGiven
    24019 
    24020 # check if user wants to skip package in any case
    24021 if 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
    24027 fi
    24028 
    24029 MUMPS_LIBS=
    24030 MUMPS_CFLAGS=
    24031 MUMPS_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
    24050 if test $coin_has_mumps != skipping; then
    24051 
    24052 # Check whether --with-m4_tolower(Mumps)-lib or --without-m4_tolower(Mumps)-lib was given.
    24053 if 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 
    24071 fi;
    24072 fi
    24073 
    24074 if test $coin_has_mumps != skipping; then
    24075 
    24076 # Check whether --with-m4_tolower(Mumps)-incdir or --without-m4_tolower(Mumps)-incdir was given.
    24077 if 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 
    24092 fi;
    24093 fi
    24094 
    24095 if test $coin_has_mumps != skipping; then
    24096 
    24097 # Check whether --with-m4_tolower(Mumps)-datadir or --without-m4_tolower(Mumps)-datadir was given.
    24098 if 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 
    24111 fi;
    24112 fi
    24113 
    24114 if 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 
    24126 if 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
    24142 echo "${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
    24163 echo "${ECHO_T}not given: $MUMPS_PKG_ERRORS" >&6
    24164 
    24165   fi
    24166 else
    24167   { { echo "$as_me:$LINENO: error: \"Cannot check for existance of module Mumps without pkg-config\"" >&5
    24168 echo "$as_me: error: \"Cannot check for existance of module Mumps without pkg-config\"" >&2;}
    24169    { (exit 1); exit 1; }; }
    24170 fi
    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
    24181 echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
    24182 
    24183 echo "$as_me:$LINENO: checking for COIN-OR package Mumps (fallback)" >&5
    24184 echo $ECHO_N "checking for COIN-OR package Mumps (fallback)... $ECHO_C" >&6
    24185 
    24186 coin_has_mumps=notGiven
    24187 MUMPS_LIBS=
    24188 MUMPS_LIBS_INSTALLED=
    24189 MUMPS_CFLAGS=
    24190 MUMPS_CFLAGS_INSTALLED=
    24191 MUMPS_DATA=
    24192 MUMPS_DATA_INSTALLED=
    24193 
    24194 # initial list of dependencies is "coinmumps", but we need to filter out version number specifications (= x, <= x, >= x)
    24195 projtoprocess="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
    24201 allproj=""
    24202 allpcfiles=""
    24203 allpcifiles=""
    24204 while 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
    24219 echo "$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
    24248 echo "${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 
    24275 done
    24276 
    24277 if 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
    24372 echo "${ECHO_T}yes" >&6
    24373 
    24374 cat >>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 
    24398 fi
    24399 
    24400 
    24401 
    24402 if test $coin_has_mumps != notGiven &&
    24403                 test $coin_has_mumps != skipping; then
    24404   COIN_HAS_MUMPS_TRUE=
    24405   COIN_HAS_MUMPS_FALSE='#'
    24406 else
    24407   COIN_HAS_MUMPS_TRUE='#'
    24408   COIN_HAS_MUMPS_FALSE=
    24409 fi
    24410 
    24411 
    24412 
    24413   fi
    24414 
    24415 else
    24416   echo "$as_me:$LINENO: result: $coin_has_mumps" >&5
    24417 echo "${ECHO_T}$coin_has_mumps" >&6
    24418 fi
    24419 
    24420 if test $coin_has_mumps != skipping &&
    24421    test $coin_has_mumps != notGiven ; then
    24422 
    24423 cat >>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.
    24429 if test "${enable_interpackage_dependencies+set}" = set; then
    24430   enableval="$enable_interpackage_dependencies"
    24431 
    24432 else
    24433   enable_interpackage_dependencies=yes
    24434 fi;
    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
    24451 echo "$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
    24455 echo "$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
    24459 echo "$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
    24463 echo "$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
    24467 echo "$as_me: Mumps CFLAGS are $MUMPS_CFLAGS" >&6;}
    24468     fi
    24469 
    24470       { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
    24471 echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
    24472       { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
    24473 echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
    24474       { echo "$as_me:$LINENO: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&5
    24475 echo "$as_me: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&6;}
    24476 
    24477   fi
    24478 fi
    24479 
    24480 # Define the Makefile conditional
    24481 
    24482 
    24483 if test $coin_has_mumps != notGiven &&
    24484                 test $coin_has_mumps != skipping; then
    24485   COIN_HAS_MUMPS_TRUE=
    24486   COIN_HAS_MUMPS_FALSE='#'
    24487 else
    24488   COIN_HAS_MUMPS_TRUE='#'
    24489   COIN_HAS_MUMPS_FALSE=
    24490 fi
    24491 
    24492 
    24493 
    24494 
    24495 # WSMP
    24496 
    24497 # Check whether --with-wsmp or --without-wsmp was given.
    24498 if test "${with_wsmp+set}" = set; then
    24499   withval="$with_wsmp"
    24500   use_wsmp=$withval
    24501 else
    24502   use_wsmp=no
    24503 fi;
    24504 
    24505 if 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 
    24525 ac_ext=f
    24526 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    24527 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    24528 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    24529 
    24530 
    24531 
    24532 
    24533 
    24534 
    24535 coin_has_f77=yes
    24536 
    24537 save_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
    24552 echo "$as_me: Trying to determine Fortran compiler name" >&6;}
    24553 for ac_prog in $coin_f77_comps
    24554 do
    24555   # Extract the first word of "$ac_prog", so it can be a program name with args.
    24556 set dummy $ac_prog; ac_word=$2
    24557 echo "$as_me:$LINENO: checking for $ac_word" >&5
    24558 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
    24559 if test "${ac_cv_prog_F77+set}" = set; then
    24560   echo $ECHO_N "(cached) $ECHO_C" >&6
    24561 else
    24562   if test -n "$F77"; then
    24563   ac_cv_prog_F77="$F77" # Let the user override the test.
    24564 else
    24565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    24566 for as_dir in $PATH
    24567 do
    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
    24576 done
    24577 done
    24578 
    24579 fi
    24580 fi
    24581 F77=$ac_cv_prog_F77
    24582 if test -n "$F77"; then
    24583   echo "$as_me:$LINENO: result: $F77" >&5
    24584 echo "${ECHO_T}$F77" >&6
    24585 else
    24586   echo "$as_me:$LINENO: result: no" >&5
    24587 echo "${ECHO_T}no" >&6
    24588 fi
    24589 
    24590   test -n "$F77" && break
    24591 done
    24592 test -n "$F77" || F77="unavailable"
    24593 
    24594 
    24595 if test "$F77" != "unavailable" ; then
    24596   ac_ext=f
    24597 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    24598 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    24599 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    24600 if 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.
    24604 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    24605 echo "$as_me:$LINENO: checking for $ac_word" >&5
    24606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
    24607 if test "${ac_cv_prog_F77+set}" = set; then
    24608   echo $ECHO_N "(cached) $ECHO_C" >&6
    24609 else
    24610   if test -n "$F77"; then
    24611   ac_cv_prog_F77="$F77" # Let the user override the test.
    24612 else
    24613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    24614 for as_dir in $PATH
    24615 do
    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
    24624 done
    24625 done
    24626 
    24627 fi
    24628 fi
    24629 F77=$ac_cv_prog_F77
    24630 if test -n "$F77"; then
    24631   echo "$as_me:$LINENO: result: $F77" >&5
    24632 echo "${ECHO_T}$F77" >&6
    24633 else
    24634   echo "$as_me:$LINENO: result: no" >&5
    24635 echo "${ECHO_T}no" >&6
    24636 fi
    24637 
    24638     test -n "$F77" && break
    24639   done
    24640 fi
    24641 if test -z "$F77"; then
    24642   ac_ct_F77=$F77
    24643   for ac_prog in $coin_f77_comps
    24644 do
    24645   # Extract the first word of "$ac_prog", so it can be a program name with args.
    24646 set dummy $ac_prog; ac_word=$2
    24647 echo "$as_me:$LINENO: checking for $ac_word" >&5
    24648 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
    24649 if test "${ac_cv_prog_ac_ct_F77+set}" = set; then
    24650   echo $ECHO_N "(cached) $ECHO_C" >&6
    24651 else
    24652   if test -n "$ac_ct_F77"; then
    24653   ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.
    24654 else
    24655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    24656 for as_dir in $PATH
    24657 do
    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
    24666 done
    24667 done
    24668 
    24669 fi
    24670 fi
    24671 ac_ct_F77=$ac_cv_prog_ac_ct_F77
    24672 if test -n "$ac_ct_F77"; then
    24673   echo "$as_me:$LINENO: result: $ac_ct_F77" >&5
    24674 echo "${ECHO_T}$ac_ct_F77" >&6
    24675 else
    24676   echo "$as_me:$LINENO: result: no" >&5
    24677 echo "${ECHO_T}no" >&6
    24678 fi
    24679 
    24680   test -n "$ac_ct_F77" && break
    24681 done
    24682 
    24683   F77=$ac_ct_F77
    24684 fi
    24685 
    24686 
    24687 # Provide some information about the compiler.
    24688 echo "$as_me:24688:" \
    24689      "checking for Fortran 77 compiler version" >&5
    24690 ac_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); }
    24706 rm -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.)
    24710 ac_save_ext=$ac_ext
    24711 ac_ext=F
    24712 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5
    24713 echo $ECHO_N "checking whether we are using the GNU Fortran 77 compiler... $ECHO_C" >&6
    24714 if test "${ac_cv_f77_compiler_gnu+set}" = set; then
    24715   echo $ECHO_N "(cached) $ECHO_C" >&6
    24716 else
    24717   cat >conftest.$ac_ext <<_ACEOF
    24718       program main
    24719 #ifndef __GNUC__
    24720        choke me
    24721 #endif
    24722 
    24723       end
    24724 _ACEOF
    24725 rm -f conftest.$ac_objext
    24726 if { (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
    24748 else
    24749   echo "$as_me: failed program was:" >&5
    24750 sed 's/^/| /' conftest.$ac_ext >&5
    24751 
    24752 ac_compiler_gnu=no
    24753 fi
    24754 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
    24755 ac_cv_f77_compiler_gnu=$ac_compiler_gnu
    24756 
    24757 fi
    24758 echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5
    24759 echo "${ECHO_T}$ac_cv_f77_compiler_gnu" >&6
    24760 ac_ext=$ac_save_ext
    24761 ac_test_FFLAGS=${FFLAGS+set}
    24762 ac_save_FFLAGS=$FFLAGS
    24763 FFLAGS=
    24764 echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5
    24765 echo $ECHO_N "checking whether $F77 accepts -g... $ECHO_C" >&6
    24766 if test "${ac_cv_prog_f77_g+set}" = set; then
    24767   echo $ECHO_N "(cached) $ECHO_C" >&6
    24768 else
    24769   FFLAGS=-g
    24770 cat >conftest.$ac_ext <<_ACEOF
    24771       program main
    24772 
    24773       end
    24774 _ACEOF
    24775 rm -f conftest.$ac_objext
    24776 if { (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
    24798 else
    24799   echo "$as_me: failed program was:" >&5
    24800 sed 's/^/| /' conftest.$ac_ext >&5
    24801 
    24802 ac_cv_prog_f77_g=no
    24803 fi
    24804 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
    24805 
    24806 fi
    24807 echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5
    24808 echo "${ECHO_T}$ac_cv_prog_f77_g" >&6
    24809 if test "$ac_test_FFLAGS" = set; then
    24810   FFLAGS=$ac_save_FFLAGS
    24811 elif 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
    24817 else
    24818   if test "x$ac_cv_f77_compiler_gnu" = xyes; then
    24819     FFLAGS="-O2"
    24820   else
    24821     FFLAGS=
    24822   fi
    24823 fi
    24824 
    24825 G77=`test $ac_compiler_gnu = yes && echo yes`
    24826 ac_ext=f
    24827 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    24828 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    24829 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    24830 
    24831 else
    24832   { echo "$as_me:$LINENO: WARNING: Failed to find a Fortran compiler!" >&5
    24833 echo "$as_me: WARNING: Failed to find a Fortran compiler!" >&2;}
    24834 fi
    24835 
    24836 FFLAGS="$save_fflags"
    24837 
    24838 # Check if a project specific FFLAGS variable has been set
    24839 if 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
    24844 fi
    24845 
    24846 if 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
    24865 rm -f conftest.$ac_objext conftest$ac_exeext
    24866 if { (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"
    24888 else
    24889   echo "$as_me: failed program was:" >&5
    24890 sed 's/^/| /' conftest.$ac_ext >&5
    24891 
    24892 fi
    24893 rm -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
    24927 rm -f conftest.$ac_objext conftest$ac_exeext
    24928 if { (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   :
    24950 else
    24951   echo "$as_me: failed program was:" >&5
    24952 sed 's/^/| /' conftest.$ac_ext >&5
    24953 
    24954 coin_add_fflags="-i_dynamic $coin_add_fflags"
    24955 fi
    24956 rm -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
    25003 rm -f conftest.$ac_objext conftest$ac_exeext
    25004 if { (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"
    25026 else
    25027   echo "$as_me: failed program was:" >&5
    25028 sed 's/^/| /' conftest.$ac_ext >&5
    25029 
    2503023177fi
    2503123178rm -f conftest.err conftest.$ac_objext \
    2503223179      conftest$ac_exeext conftest.$ac_ext
    2503323180  fi
    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
    25055 else
    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
    25063 fi
    25064 
    25065 # If FFLAGS contains -mno-cygwin, CPPFLAGS must have it.
    25066 case "$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 ;;
    25079 esac
    25080 
    25081 # Try if FFLAGS works
    25082 if test "$F77" != "unavailable" ; then
    25083   cat >conftest.$ac_ext <<_ACEOF
    25084       program main
    25085       integer i
    25086       end
    25087 _ACEOF
    25088 rm -f conftest.$ac_objext conftest$ac_exeext
    25089 if { (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   :
    25111 else
    25112   echo "$as_me: failed program was:" >&5
    25113 sed 's/^/| /' conftest.$ac_ext >&5
    25114 
    25115 FFLAGS=
    25116 fi
    25117 rm -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
    25121 echo "$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
    25128 rm -f conftest.$ac_objext conftest$ac_exeext
    25129 if { (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   :
    25151 else
    25152   echo "$as_me: failed program was:" >&5
    25153 sed 's/^/| /' conftest.$ac_ext >&5
    25154 
    25155 FFLAGS=
    25156 fi
    25157 rm -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
    25161 echo "$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
    25164 fi
    25165 
    25166 { echo "$as_me:$LINENO: Fortran compiler options are: $FFLAGS" >&5
    25167 echo "$as_me: Fortran compiler options are: $FFLAGS" >&6;}
    25168 
    25169 
    25170 if test x"$MPIF77" = x; then :; else
    25171   { echo "$as_me:$LINENO: Will use MPI Fortran compiler $MPIF77" >&5
    25172 echo "$as_me: Will use MPI Fortran compiler $MPIF77" >&6;}
    25173   F77="$MPIF77"
    25174 fi
    25175 
    25176 # correct the LD variable if we use the intel fortran compiler in windows
    25177 case "$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     ;;
    25195 esac
    25196 
    25197 ac_ext=c
    25198 ac_cpp='$CPP $CPPFLAGS'
    25199 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    25200 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25201 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    25202 
    25203 
    25204   ac_ext=f
    25205 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25206 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25207 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25208 echo "$as_me:$LINENO: checking how to get verbose linking output from $F77" >&5
    25209 echo $ECHO_N "checking how to get verbose linking output from $F77... $ECHO_C" >&6
    25210 if test "${ac_cv_prog_f77_v+set}" = set; then
    25211   echo $ECHO_N "(cached) $ECHO_C" >&6
    25212 else
    25213   cat >conftest.$ac_ext <<_ACEOF
    25214       program main
    25215 
    25216       end
    25217 _ACEOF
    25218 rm -f conftest.$ac_objext
    25219 if { (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
    25242 for 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.
    25253 ac_save_FFLAGS=$FFLAGS
    25254 FFLAGS="$FFLAGS $ac_verb"
    25255 (eval echo $as_me:25255: \"$ac_link\") >&5
    25256 ac_f77_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
    25257 echo "$ac_f77_v_output" >&5
    25258 FFLAGS=$ac_save_FFLAGS
    25259 
    25260 rm -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):
    25265 ac_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 
    25269 case $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"` ;;
    25284 esac
    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
    25295 done
    25296 if test -z "$ac_cv_prog_f77_v"; then
    25297    { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F77" >&5
    25298 echo "$as_me: WARNING: cannot determine how to obtain linking information from $F77" >&2;}
    25299 fi
    25300 else
    25301   echo "$as_me: failed program was:" >&5
    25302 sed 's/^/| /' conftest.$ac_ext >&5
    25303 
    25304 { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
    25305 echo "$as_me: WARNING: compilation failed" >&2;}
    25306 fi
    25307 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
    25308 
    25309 fi
    25310 echo "$as_me:$LINENO: result: $ac_cv_prog_f77_v" >&5
    25311 echo "${ECHO_T}$ac_cv_prog_f77_v" >&6
    25312 echo "$as_me:$LINENO: checking for Fortran libraries of $F77" >&5
    25313 echo $ECHO_N "checking for Fortran libraries of $F77... $ECHO_C" >&6
    25314 if test "${ac_cv_f77_libs+set}" = set; then
    25315   echo $ECHO_N "(cached) $ECHO_C" >&6
    25316 else
    25317   if test "x$FLIBS" != "x"; then
    25318   ac_cv_f77_libs="$FLIBS" # Let the user override the test.
    25319 else
    25320 
    25321 cat >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.
    25331 ac_save_FFLAGS=$FFLAGS
    25332 FFLAGS="$FFLAGS $ac_cv_prog_f77_v"
    25333 (eval echo $as_me:25333: \"$ac_link\") >&5
    25334 ac_f77_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
    25335 echo "$ac_f77_v_output" >&5
    25336 FFLAGS=$ac_save_FFLAGS
    25337 
    25338 rm -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):
    25343 ac_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 
    25347 case $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"` ;;
    25362 esac
    25363 
    25364 
    25365 
    25366 ac_cv_f77_libs=
    25367 
    25368 # Save positional arguments (if any)
    25369 ac_save_positional="$@"
    25370 
    25371 set X $ac_f77_v_output
    25372 while 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   :
    25387 else
    25388   ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
    25389 fi
    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   :
    25403 else
    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
    25408 else
    25409   ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
    25410 fi
    25411 fi
    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   :
    25445 else
    25446   ac_arg="$ac_arg $ac_j"
    25447                                ac_cv_f77_libs="$ac_cv_f77_libs $ac_j"
    25448 fi
    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   :
    25463 else
    25464   ac_cv_f77_libs="$ac_cv_f77_libs $ac_arg"
    25465 fi
    25466 
    25467           ;;
    25468           # Ignore everything else.
    25469   esac
    25470 done
    25471 # restore positional arguments
    25472 set 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 "/").
    25477 case `(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
    25486 else
    25487   ac_cv_f77_libs="$ac_cv_f77_libs $ac_ld_run_path"
    25488 fi
    25489       ;;
    25490 esac
    25491 fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
    25492 
    25493 fi
    25494 echo "$as_me:$LINENO: result: $ac_cv_f77_libs" >&5
    25495 echo "${ECHO_T}$ac_cv_f77_libs" >&6
    25496 FLIBS="$ac_cv_f77_libs"
    25497 
    25498 
    25499 ac_ext=f
    25500 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25501 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25502 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25503 
    25504 ac_ext=f
    25505 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25506 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25507 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25508 
    25509 echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
    25510 echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
    25511 if test "${ac_cv_f77_dummy_main+set}" = set; then
    25512   echo $ECHO_N "(cached) $ECHO_C" >&6
    25513 else
    25514   ac_f77_dm_save_LIBS=$LIBS
    25515  LIBS="$LIBS $FLIBS"
    25516  ac_fortran_dm_var=F77_DUMMY_MAIN
    25517  ac_ext=c
    25518 ac_cpp='$CPP $CPPFLAGS'
    25519 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    25520 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25521 ac_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
    25527 cat confdefs.h >>conftest.$ac_ext
    25528 cat >>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
    25539 int
    25540 main ()
    25541 {
    25542 
    25543   ;
    25544   return 0;
    25545 }
    25546 _ACEOF
    25547 rm -f conftest.$ac_objext conftest$ac_exeext
    25548 if { (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
    25570 else
    25571   echo "$as_me: failed program was:" >&5
    25572 sed 's/^/| /' conftest.$ac_ext >&5
    25573 
    25574 ac_cv_fortran_dummy_main=unknown
    25575 fi
    25576 rm -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
    25584 cat confdefs.h >>conftest.$ac_ext
    25585 cat >>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
    25596 int
    25597 main ()
    25598 {
    25599 
    25600   ;
    25601   return 0;
    25602 }
    25603 _ACEOF
    25604 rm -f conftest.$ac_objext conftest$ac_exeext
    25605 if { (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
    25627 else
    25628   echo "$as_me: failed program was:" >&5
    25629 sed 's/^/| /' conftest.$ac_ext >&5
    25630 
    25631 fi
    25632 rm -f conftest.err conftest.$ac_objext \
    25633       conftest$ac_exeext conftest.$ac_ext
    25634    done
    25635  fi
    25636  ac_ext=f
    25637 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25638 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25639 ac_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 
    25644 fi
    25645 echo "$as_me:$LINENO: result: $ac_cv_f77_dummy_main" >&5
    25646 echo "${ECHO_T}$ac_cv_f77_dummy_main" >&6
    25647 F77_DUMMY_MAIN=$ac_cv_f77_dummy_main
    25648 if test "$F77_DUMMY_MAIN" != unknown; then
    25649   if test $F77_DUMMY_MAIN != none; then
    25650 
    25651 cat >>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 
    25657 cat >>confdefs.h <<\_ACEOF
    25658 #define FC_DUMMY_MAIN_EQ_F77 1
    25659 _ACEOF
    25660 
    25661   fi
    25662 fi
    25663 else
    25664   { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
    25665 See \`config.log' for more details." >&5
    25666 echo "$as_me: error: linking to Fortran libraries from C fails
    25667 See \`config.log' for more details." >&2;}
    25668    { (exit 1); exit 1; }; }
    25669 fi
    25670 
    25671 
    25672 ac_ext=f
    25673 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25674 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25675 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25676 
    25677 ac_ext=f
    25678 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25679 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25680 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25681 echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
    25682 echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
    25683 if test "${ac_cv_f77_mangling+set}" = set; then
    25684   echo $ECHO_N "(cached) $ECHO_C" >&6
    25685 else
    25686   cat >conftest.$ac_ext <<_ACEOF
    25687       subroutine foobar()
    25688       return
    25689       end
    25690       subroutine foo_bar()
    25691       return
    25692       end
    25693 _ACEOF
    25694 rm -f conftest.$ac_objext
    25695 if { (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
    25722 ac_cpp='$CPP $CPPFLAGS'
    25723 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    25724 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25725 ac_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
    25733 cat confdefs.h >>conftest.$ac_ext
    25734 cat >>conftest.$ac_ext <<_ACEOF
    25735 /* end confdefs.h.  */
    25736 
    25737 /* Override any gcc2 internal prototype to avoid an error.  */
    25738 #ifdef __cplusplus
    25739 extern "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.  */
    25743 char $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
    25752 int
    25753 main ()
    25754 {
    25755 $ac_func ();
    25756   ;
    25757   return 0;
    25758 }
    25759 _ACEOF
    25760 rm -f conftest.$ac_objext conftest$ac_exeext
    25761 if { (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
    25783 else
    25784   echo "$as_me: failed program was:" >&5
    25785 sed 's/^/| /' conftest.$ac_ext >&5
    25786 
    25787 fi
    25788 rm -f conftest.err conftest.$ac_objext \
    25789       conftest$ac_exeext conftest.$ac_ext
    25790     done
    25791   done
    25792   ac_ext=f
    25793 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25794 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25795 ac_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
    25810 ac_cpp='$CPP $CPPFLAGS'
    25811 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    25812 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25813 ac_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
    25820 cat confdefs.h >>conftest.$ac_ext
    25821 cat >>conftest.$ac_ext <<_ACEOF
    25822 /* end confdefs.h.  */
    25823 
    25824 /* Override any gcc2 internal prototype to avoid an error.  */
    25825 #ifdef __cplusplus
    25826 extern "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.  */
    25830 char $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
    25839 int
    25840 main ()
    25841 {
    25842 $ac_func ();
    25843   ;
    25844   return 0;
    25845 }
    25846 _ACEOF
    25847 rm -f conftest.$ac_objext conftest$ac_exeext
    25848 if { (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
    25870 else
    25871   echo "$as_me: failed program was:" >&5
    25872 sed 's/^/| /' conftest.$ac_ext >&5
    25873 
    25874 fi
    25875 rm -f conftest.err conftest.$ac_objext \
    25876       conftest$ac_exeext conftest.$ac_ext
    25877      done
    25878      ac_ext=f
    25879 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25880 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25881 ac_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*
    25904 else
    25905   echo "$as_me: failed program was:" >&5
    25906 sed 's/^/| /' conftest.$ac_ext >&5
    25907 
    25908 { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
    25909 See \`config.log' for more details." >&5
    25910 echo "$as_me: error: cannot compile a simple Fortran program
    25911 See \`config.log' for more details." >&2;}
    25912    { (exit 1); exit 1; }; }
    25913 fi
    25914 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
    25915 
    25916 fi
    25917 echo "$as_me:$LINENO: result: $ac_cv_f77_mangling" >&5
    25918 echo "${ECHO_T}$ac_cv_f77_mangling" >&6
    25919 
    25920 ac_ext=f
    25921 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25922 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25923 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25924 
    25925 
    25926 ac_ext=f
    25927 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25928 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25929 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25930 
    25931 
    25932 ac_ext=f
    25933 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    25934 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    25935 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    25936 
    25937 
    25938 case $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
    26013 echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
    26014           ;;
    26015 esac
    26016 
    26017 ac_ext=f
    26018 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    26019 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26020 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    26021 
    26022 
    26023 # If FLIBS has been set by the user, we just restore its value here
    26024 if test x"$save_FLIBS" != x; then
    26025   FLIBS="$save_FLIBS"
    26026 else
    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"
    26073 fi
    26074 
    26075 ac_ext=c
    26076 ac_cpp='$CPP $CPPFLAGS'
    26077 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    26078 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26079 ac_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.
    26088 if test "${with_blas+set}" = set; then
    26089   withval="$with_blas"
    26090   use_blas="$withval"
    26091 else
    26092   use_blas=
    26093 fi;
    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.
    26099 if test "${with_blas_lib+set}" = set; then
    26100   withval="$with_blas_lib"
    26101   use_blas=BUILD
    26102 fi;
    26103 
    26104 # Check if user supplied option makes sense
    26105 if 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
    26111 echo $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
    26120 cat confdefs.h >>conftest.$ac_ext
    26121 cat >>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
    26132 int
    26133 main ()
    26134 {
    26135       call daxpy
    26136   ;
    26137   return 0;
    26138 }
    26139 _ACEOF
    26140 rm -f conftest.$ac_objext conftest$ac_exeext
    26141 if { (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
    26166 echo "${ECHO_T}yes: $use_blas" >&6
    26167 else
    26168   echo "$as_me: failed program was:" >&5
    26169 sed 's/^/| /' conftest.$ac_ext >&5
    26170 
    26171 echo "$as_me:$LINENO: result: no" >&5
    26172 echo "${ECHO_T}no" >&6
    26173                        { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
    26174 echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
    26175    { (exit 1); exit 1; }; }
    26176 fi
    26177 rm -f conftest.err conftest.$ac_objext \
    26178       conftest$ac_exeext conftest.$ac_ext
    26179     ;;
    26180   c)
    26181     ac_ext=f
    26182 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    26183 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26184 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    26185 case $ac_cv_f77_mangling in
    26186   upper*) ac_val="DAXPY" ;;
    26187   lower*) ac_val="daxpy" ;;
    26188   *)      ac_val="unknown" ;;
    26189 esac
    26190 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    26191 
    26192 cfuncdaxpy="$ac_val"
    26193 
    26194 ac_ext=c
    26195 ac_cpp='$CPP $CPPFLAGS'
    26196 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    26197 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26198 ac_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
    26206 cat confdefs.h >>conftest.$ac_ext
    26207 cat >>conftest.$ac_ext <<_ACEOF
    26208 /* end confdefs.h.  */
    26209 void $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
    26218 int
    26219 main ()
    26220 {
    26221 $cfuncdaxpy()
    26222   ;
    26223   return 0;
    26224 }
    26225 _ACEOF
    26226 rm -f conftest.$ac_objext conftest$ac_exeext
    26227 if { (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
    26249 else
    26250   echo "$as_me: failed program was:" >&5
    26251 sed 's/^/| /' conftest.$ac_ext >&5
    26252 
    26253 flink_try=no
    26254 fi
    26255 rm -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
    26263 echo "${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
    26271 cat confdefs.h >>conftest.$ac_ext
    26272 cat >>conftest.$ac_ext <<_ACEOF
    26273 /* end confdefs.h.  */
    26274 void $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
    26283 int
    26284 main ()
    26285 {
    26286 $cfuncdaxpy()
    26287   ;
    26288   return 0;
    26289 }
    26290 _ACEOF
    26291 rm -f conftest.$ac_objext conftest$ac_exeext
    26292 if { (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
    26319 echo "${ECHO_T}yes: $use_blas" >&6
    26320 
    26321 else
    26322   echo "$as_me: failed program was:" >&5
    26323 sed 's/^/| /' conftest.$ac_ext >&5
    26324 
    26325 LIBS="$flink_save_libs"
    26326                      echo "$as_me:$LINENO: result: no" >&5
    26327 echo "${ECHO_T}no" >&6
    26328                        { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
    26329 echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
    26330    { (exit 1); exit 1; }; }
    26331 fi
    26332 rm -f conftest.err conftest.$ac_objext \
    26333       conftest$ac_exeext conftest.$ac_ext
    26334       else
    26335         echo "$as_me:$LINENO: result: no" >&5
    26336 echo "${ECHO_T}no" >&6
    26337                        { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
    26338 echo "$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
    26345 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    26346 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26347 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    26348 case $ac_cv_f77_mangling in
    26349   upper*) ac_val="DAXPY" ;;
    26350   lower*) ac_val="daxpy" ;;
    26351   *)      ac_val="unknown" ;;
    26352 esac
    26353 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    26354 
    26355 cfuncdaxpy="$ac_val"
    26356 
    26357 ac_ext=c
    26358 ac_cpp='$CPP $CPPFLAGS'
    26359 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    26360 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26361 ac_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
    26369 cat confdefs.h >>conftest.$ac_ext
    26370 cat >>conftest.$ac_ext <<_ACEOF
    26371 /* end confdefs.h.  */
    26372 extern "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
    26381 int
    26382 main ()
    26383 {
    26384 $cfuncdaxpy()
    26385   ;
    26386   return 0;
    26387 }
    26388 _ACEOF
    26389 rm -f conftest.$ac_objext conftest$ac_exeext
    26390 if { (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
    26412 else
    26413   echo "$as_me: failed program was:" >&5
    26414 sed 's/^/| /' conftest.$ac_ext >&5
    26415 
    26416 flink_try=no
    26417 fi
    26418 rm -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
    26426 echo "${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
    26434 cat confdefs.h >>conftest.$ac_ext
    26435 cat >>conftest.$ac_ext <<_ACEOF
    26436 /* end confdefs.h.  */
    26437 extern "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
    26446 int
    26447 main ()
    26448 {
    26449 $cfuncdaxpy()
    26450   ;
    26451   return 0;
    26452 }
    26453 _ACEOF
    26454 rm -f conftest.$ac_objext conftest$ac_exeext
    26455 if { (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
    26482 echo "${ECHO_T}yes: $use_blas" >&6
    26483 
    26484 else
    26485   echo "$as_me: failed program was:" >&5
    26486 sed 's/^/| /' conftest.$ac_ext >&5
    26487 
    26488 LIBS="$flink_save_libs"
    26489                      echo "$as_me:$LINENO: result: no" >&5
    26490 echo "${ECHO_T}no" >&6
    26491                        { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
    26492 echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
    26493    { (exit 1); exit 1; }; }
    26494 fi
    26495 rm -f conftest.err conftest.$ac_objext \
    26496       conftest$ac_exeext conftest.$ac_ext
    26497       else
    26498         echo "$as_me:$LINENO: result: no" >&5
    26499 echo "${ECHO_T}no" >&6
    26500                        { { echo "$as_me:$LINENO: error: user supplied BLAS library \"$use_blas\" does not work" >&5
    26501 echo "$as_me: error: user supplied BLAS library \"$use_blas\" does not work" >&2;}
    26502    { (exit 1); exit 1; }; }
    26503       fi
    26504     fi
    26505     ;;
    26506 esac
    26507 
    26508     LIBS="$coin_save_LIBS"
    26509   fi
    26510 else
    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
    26517 echo $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
    26526 cat confdefs.h >>conftest.$ac_ext
    26527 cat >>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
    26538 int
    26539 main ()
    26540 {
    26541       call daxpy
    26542   ;
    26543   return 0;
    26544 }
    26545 _ACEOF
    26546 rm -f conftest.$ac_objext conftest$ac_exeext
    26547 if { (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
    26573 echo "${ECHO_T}yes: $use_blas" >&6
    26574 
    26575 else
    26576   echo "$as_me: failed program was:" >&5
    26577 sed 's/^/| /' conftest.$ac_ext >&5
    26578 
    26579 echo "$as_me:$LINENO: result: no" >&5
    26580 echo "${ECHO_T}no" >&6
    26581 fi
    26582 rm -f conftest.err conftest.$ac_objext \
    26583       conftest$ac_exeext conftest.$ac_ext
    26584     ;;
    26585   c)
    26586     ac_ext=f
    26587 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    26588 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26589 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    26590 case $ac_cv_f77_mangling in
    26591   upper*) ac_val="DAXPY" ;;
    26592   lower*) ac_val="daxpy" ;;
    26593   *)      ac_val="unknown" ;;
    26594 esac
    26595 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    26596 
    26597 cfuncdaxpy="$ac_val"
    26598 
    26599 ac_ext=c
    26600 ac_cpp='$CPP $CPPFLAGS'
    26601 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    26602 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26603 ac_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
    26611 cat confdefs.h >>conftest.$ac_ext
    26612 cat >>conftest.$ac_ext <<_ACEOF
    26613 /* end confdefs.h.  */
    26614 void $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
    26623 int
    26624 main ()
    26625 {
    26626 $cfuncdaxpy()
    26627   ;
    26628   return 0;
    26629 }
    26630 _ACEOF
    26631 rm -f conftest.$ac_objext conftest$ac_exeext
    26632 if { (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
    26654 else
    26655   echo "$as_me: failed program was:" >&5
    26656 sed 's/^/| /' conftest.$ac_ext >&5
    26657 
    26658 flink_try=no
    26659 fi
    26660 rm -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
    26669 echo "${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
    26678 cat confdefs.h >>conftest.$ac_ext
    26679 cat >>conftest.$ac_ext <<_ACEOF
    26680 /* end confdefs.h.  */
    26681 void $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
    26690 int
    26691 main ()
    26692 {
    26693 $cfuncdaxpy()
    26694   ;
    26695   return 0;
    26696 }
    26697 _ACEOF
    26698 rm -f conftest.$ac_objext conftest$ac_exeext
    26699 if { (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
    26727 echo "${ECHO_T}yes: $use_blas" >&6
    26728 
    26729 
    26730 else
    26731   echo "$as_me: failed program was:" >&5
    26732 sed 's/^/| /' conftest.$ac_ext >&5
    26733 
    26734 LIBS="$flink_save_libs"
    26735                      echo "$as_me:$LINENO: result: no" >&5
    26736 echo "${ECHO_T}no" >&6
    26737 fi
    26738 rm -f conftest.err conftest.$ac_objext \
    26739       conftest$ac_exeext conftest.$ac_ext
    26740       else
    26741         echo "$as_me:$LINENO: result: no" >&5
    26742 echo "${ECHO_T}no" >&6
    26743       fi
    26744     fi
    26745     ;;
    26746   cc|cpp)
    26747     ac_ext=f
    26748 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    26749 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26750 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    26751 case $ac_cv_f77_mangling in
    26752   upper*) ac_val="DAXPY" ;;
    26753   lower*) ac_val="daxpy" ;;
    26754   *)      ac_val="unknown" ;;
    26755 esac
    26756 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    26757 
    26758 cfuncdaxpy="$ac_val"
    26759 
    26760 ac_ext=c
    26761 ac_cpp='$CPP $CPPFLAGS'
    26762 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    26763 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26764 ac_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
    26772 cat confdefs.h >>conftest.$ac_ext
    26773 cat >>conftest.$ac_ext <<_ACEOF
    26774 /* end confdefs.h.  */
    26775 extern "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
    26784 int
    26785 main ()
    26786 {
    26787 $cfuncdaxpy()
    26788   ;
    26789   return 0;
    26790 }
    26791 _ACEOF
    26792 rm -f conftest.$ac_objext conftest$ac_exeext
    26793 if { (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
    26815 else
    26816   echo "$as_me: failed program was:" >&5
    26817 sed 's/^/| /' conftest.$ac_ext >&5
    26818 
    26819 flink_try=no
    26820 fi
    26821 rm -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
    26830 echo "${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
    26839 cat confdefs.h >>conftest.$ac_ext
    26840 cat >>conftest.$ac_ext <<_ACEOF
    26841 /* end confdefs.h.  */
    26842 extern "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
    26851 int
    26852 main ()
    26853 {
    26854 $cfuncdaxpy()
    26855   ;
    26856   return 0;
    26857 }
    26858 _ACEOF
    26859 rm -f conftest.$ac_objext conftest$ac_exeext
    26860 if { (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
    26888 echo "${ECHO_T}yes: $use_blas" >&6
    26889 
    26890 
    26891 else
    26892   echo "$as_me: failed program was:" >&5
    26893 sed 's/^/| /' conftest.$ac_ext >&5
    26894 
    26895 LIBS="$flink_save_libs"
    26896                      echo "$as_me:$LINENO: result: no" >&5
    26897 echo "${ECHO_T}no" >&6
    26898 fi
    26899 rm -f conftest.err conftest.$ac_objext \
    26900       conftest$ac_exeext conftest.$ac_ext
    26901       else
    26902         echo "$as_me:$LINENO: result: no" >&5
    26903 echo "${ECHO_T}no" >&6
    26904       fi
    26905     fi
    26906     ;;
    26907 esac
    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
    26920 echo $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
    26929 cat confdefs.h >>conftest.$ac_ext
    26930 cat >>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
    26941 int
    26942 main ()
    26943 {
    26944       call daxpy
    26945   ;
    26946   return 0;
    26947 }
    26948 _ACEOF
    26949 rm -f conftest.$ac_objext conftest$ac_exeext
    26950 if { (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
    26976 echo "${ECHO_T}yes: $use_blas" >&6
    26977 
    26978 else
    26979   echo "$as_me: failed program was:" >&5
    26980 sed 's/^/| /' conftest.$ac_ext >&5
    26981 
    26982 echo "$as_me:$LINENO: result: no" >&5
    26983 echo "${ECHO_T}no" >&6
    26984 fi
    26985 rm -f conftest.err conftest.$ac_objext \
    26986       conftest$ac_exeext conftest.$ac_ext
    26987     ;;
    26988   c)
    26989     ac_ext=f
    26990 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    26991 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    26992 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    26993 case $ac_cv_f77_mangling in
    26994   upper*) ac_val="DAXPY" ;;
    26995   lower*) ac_val="daxpy" ;;
    26996   *)      ac_val="unknown" ;;
    26997 esac
    26998 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    26999 
    27000 cfuncdaxpy="$ac_val"
    27001 
    27002 ac_ext=c
    27003 ac_cpp='$CPP $CPPFLAGS'
    27004 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    27005 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27006 ac_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
    27014 cat confdefs.h >>conftest.$ac_ext
    27015 cat >>conftest.$ac_ext <<_ACEOF
    27016 /* end confdefs.h.  */
    27017 void $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
    27026 int
    27027 main ()
    27028 {
    27029 $cfuncdaxpy()
    27030   ;
    27031   return 0;
    27032 }
    27033 _ACEOF
    27034 rm -f conftest.$ac_objext conftest$ac_exeext
    27035 if { (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
    27057 else
    27058   echo "$as_me: failed program was:" >&5
    27059 sed 's/^/| /' conftest.$ac_ext >&5
    27060 
    27061 flink_try=no
    27062 fi
    27063 rm -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
    27072 echo "${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
    27081 cat confdefs.h >>conftest.$ac_ext
    27082 cat >>conftest.$ac_ext <<_ACEOF
    27083 /* end confdefs.h.  */
    27084 void $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
    27093 int
    27094 main ()
    27095 {
    27096 $cfuncdaxpy()
    27097   ;
    27098   return 0;
    27099 }
    27100 _ACEOF
    27101 rm -f conftest.$ac_objext conftest$ac_exeext
    27102 if { (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
    27130 echo "${ECHO_T}yes: $use_blas" >&6
    27131 
    27132 
    27133 else
    27134   echo "$as_me: failed program was:" >&5
    27135 sed 's/^/| /' conftest.$ac_ext >&5
    27136 
    27137 LIBS="$flink_save_libs"
    27138                      echo "$as_me:$LINENO: result: no" >&5
    27139 echo "${ECHO_T}no" >&6
    27140 fi
    27141 rm -f conftest.err conftest.$ac_objext \
    27142       conftest$ac_exeext conftest.$ac_ext
    27143       else
    27144         echo "$as_me:$LINENO: result: no" >&5
    27145 echo "${ECHO_T}no" >&6
    27146       fi
    27147     fi
    27148     ;;
    27149   cc|cpp)
    27150     ac_ext=f
    27151 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    27152 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27153 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    27154 case $ac_cv_f77_mangling in
    27155   upper*) ac_val="DAXPY" ;;
    27156   lower*) ac_val="daxpy" ;;
    27157   *)      ac_val="unknown" ;;
    27158 esac
    27159 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    27160 
    27161 cfuncdaxpy="$ac_val"
    27162 
    27163 ac_ext=c
    27164 ac_cpp='$CPP $CPPFLAGS'
    27165 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    27166 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27167 ac_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
    27175 cat confdefs.h >>conftest.$ac_ext
    27176 cat >>conftest.$ac_ext <<_ACEOF
    27177 /* end confdefs.h.  */
    27178 extern "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
    27187 int
    27188 main ()
    27189 {
    27190 $cfuncdaxpy()
    27191   ;
    27192   return 0;
    27193 }
    27194 _ACEOF
    27195 rm -f conftest.$ac_objext conftest$ac_exeext
    27196 if { (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
    27218 else
    27219   echo "$as_me: failed program was:" >&5
    27220 sed 's/^/| /' conftest.$ac_ext >&5
    27221 
    27222 flink_try=no
    27223 fi
    27224 rm -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
    27233 echo "${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
    27242 cat confdefs.h >>conftest.$ac_ext
    27243 cat >>conftest.$ac_ext <<_ACEOF
    27244 /* end confdefs.h.  */
    27245 extern "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
    27254 int
    27255 main ()
    27256 {
    27257 $cfuncdaxpy()
    27258   ;
    27259   return 0;
    27260 }
    27261 _ACEOF
    27262 rm -f conftest.$ac_objext conftest$ac_exeext
    27263 if { (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
    27291 echo "${ECHO_T}yes: $use_blas" >&6
    27292 
    27293 
    27294 else
    27295   echo "$as_me: failed program was:" >&5
    27296 sed 's/^/| /' conftest.$ac_ext >&5
    27297 
    27298 LIBS="$flink_save_libs"
    27299                      echo "$as_me:$LINENO: result: no" >&5
    27300 echo "${ECHO_T}no" >&6
    27301 fi
    27302 rm -f conftest.err conftest.$ac_objext \
    27303       conftest$ac_exeext conftest.$ac_ext
    27304       else
    27305         echo "$as_me:$LINENO: result: no" >&5
    27306 echo "${ECHO_T}no" >&6
    27307       fi
    27308     fi
    27309     ;;
    27310 esac
    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
    27325 echo $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
    27332 cat confdefs.h >>conftest.$ac_ext
    27333 cat >>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
    27344 int
    27345 main ()
    27346 {
    27347       call daxpy
    27348   ;
    27349   return 0;
    27350 }
    27351 _ACEOF
    27352 rm -f conftest.$ac_objext conftest$ac_exeext
    27353 if { (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
    27376 echo "${ECHO_T}yes: $use_blas" >&6
    27377 
    27378 else
    27379   echo "$as_me: failed program was:" >&5
    27380 sed 's/^/| /' conftest.$ac_ext >&5
    27381 
    27382 echo "$as_me:$LINENO: result: no" >&5
    27383 echo "${ECHO_T}no" >&6
    27384 fi
    27385 rm -f conftest.err conftest.$ac_objext \
    27386       conftest$ac_exeext conftest.$ac_ext
    27387     ;;
    27388   c)
    27389     ac_ext=f
    27390 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    27391 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27392 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    27393 case $ac_cv_f77_mangling in
    27394   upper*) ac_val="DAXPY" ;;
    27395   lower*) ac_val="daxpy" ;;
    27396   *)      ac_val="unknown" ;;
    27397 esac
    27398 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    27399 
    27400 cfuncdaxpy="$ac_val"
    27401 
    27402 ac_ext=c
    27403 ac_cpp='$CPP $CPPFLAGS'
    27404 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    27405 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27406 ac_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
    27414 cat confdefs.h >>conftest.$ac_ext
    27415 cat >>conftest.$ac_ext <<_ACEOF
    27416 /* end confdefs.h.  */
    27417 void $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
    27426 int
    27427 main ()
    27428 {
    27429 $cfuncdaxpy()
    27430   ;
    27431   return 0;
    27432 }
    27433 _ACEOF
    27434 rm -f conftest.$ac_objext conftest$ac_exeext
    27435 if { (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
    27457 else
    27458   echo "$as_me: failed program was:" >&5
    27459 sed 's/^/| /' conftest.$ac_ext >&5
    27460 
    27461 flink_try=no
    27462 fi
    27463 rm -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
    27469 echo "${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
    27478 cat confdefs.h >>conftest.$ac_ext
    27479 cat >>conftest.$ac_ext <<_ACEOF
    27480 /* end confdefs.h.  */
    27481 void $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
    27490 int
    27491 main ()
    27492 {
    27493 $cfuncdaxpy()
    27494   ;
    27495   return 0;
    27496 }
    27497 _ACEOF
    27498 rm -f conftest.$ac_objext conftest$ac_exeext
    27499 if { (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
    27524 echo "${ECHO_T}yes: $use_blas" >&6
    27525 
    27526 
    27527 else
    27528   echo "$as_me: failed program was:" >&5
    27529 sed 's/^/| /' conftest.$ac_ext >&5
    27530 
    27531 LIBS="$flink_save_libs"
    27532                      echo "$as_me:$LINENO: result: no" >&5
    27533 echo "${ECHO_T}no" >&6
    27534 fi
    27535 rm -f conftest.err conftest.$ac_objext \
    27536       conftest$ac_exeext conftest.$ac_ext
    27537       else
    27538         echo "$as_me:$LINENO: result: no" >&5
    27539 echo "${ECHO_T}no" >&6
    27540       fi
    27541     fi
    27542     ;;
    27543   cc|cpp)
    27544     ac_ext=f
    27545 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    27546 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27547 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    27548 case $ac_cv_f77_mangling in
    27549   upper*) ac_val="DAXPY" ;;
    27550   lower*) ac_val="daxpy" ;;
    27551   *)      ac_val="unknown" ;;
    27552 esac
    27553 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    27554 
    27555 cfuncdaxpy="$ac_val"
    27556 
    27557 ac_ext=c
    27558 ac_cpp='$CPP $CPPFLAGS'
    27559 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    27560 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27561 ac_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
    27569 cat confdefs.h >>conftest.$ac_ext
    27570 cat >>conftest.$ac_ext <<_ACEOF
    27571 /* end confdefs.h.  */
    27572 extern "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
    27581 int
    27582 main ()
    27583 {
    27584 $cfuncdaxpy()
    27585   ;
    27586   return 0;
    27587 }
    27588 _ACEOF
    27589 rm -f conftest.$ac_objext conftest$ac_exeext
    27590 if { (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
    27612 else
    27613   echo "$as_me: failed program was:" >&5
    27614 sed 's/^/| /' conftest.$ac_ext >&5
    27615 
    27616 flink_try=no
    27617 fi
    27618 rm -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
    27624 echo "${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
    27633 cat confdefs.h >>conftest.$ac_ext
    27634 cat >>conftest.$ac_ext <<_ACEOF
    27635 /* end confdefs.h.  */
    27636 extern "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
    27645 int
    27646 main ()
    27647 {
    27648 $cfuncdaxpy()
    27649   ;
    27650   return 0;
    27651 }
    27652 _ACEOF
    27653 rm -f conftest.$ac_objext conftest$ac_exeext
    27654 if { (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
    27679 echo "${ECHO_T}yes: $use_blas" >&6
    27680 
    27681 
    27682 else
    27683   echo "$as_me: failed program was:" >&5
    27684 sed 's/^/| /' conftest.$ac_ext >&5
    27685 
    27686 LIBS="$flink_save_libs"
    27687                      echo "$as_me:$LINENO: result: no" >&5
    27688 echo "${ECHO_T}no" >&6
    27689 fi
    27690 rm -f conftest.err conftest.$ac_objext \
    27691       conftest$ac_exeext conftest.$ac_ext
    27692       else
    27693         echo "$as_me:$LINENO: result: no" >&5
    27694 echo "${ECHO_T}no" >&6
    27695       fi
    27696     fi
    27697     ;;
    27698 esac
    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
    27704 echo $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
    27711 cat confdefs.h >>conftest.$ac_ext
    27712 cat >>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
    27723 int
    27724 main ()
    27725 {
    27726       call daxpy
    27727   ;
    27728   return 0;
    27729 }
    27730 _ACEOF
    27731 rm -f conftest.$ac_objext conftest$ac_exeext
    27732 if { (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
    27755 echo "${ECHO_T}yes: $use_blas" >&6
    27756 
    27757 else
    27758   echo "$as_me: failed program was:" >&5
    27759 sed 's/^/| /' conftest.$ac_ext >&5
    27760 
    27761 echo "$as_me:$LINENO: result: no" >&5
    27762 echo "${ECHO_T}no" >&6
    27763 fi
    27764 rm -f conftest.err conftest.$ac_objext \
    27765       conftest$ac_exeext conftest.$ac_ext
    27766     ;;
    27767   c)
    27768     ac_ext=f
    27769 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    27770 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27771 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    27772 case $ac_cv_f77_mangling in
    27773   upper*) ac_val="DAXPY" ;;
    27774   lower*) ac_val="daxpy" ;;
    27775   *)      ac_val="unknown" ;;
    27776 esac
    27777 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    27778 
    27779 cfuncdaxpy="$ac_val"
    27780 
    27781 ac_ext=c
    27782 ac_cpp='$CPP $CPPFLAGS'
    27783 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    27784 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27785 ac_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
    27793 cat confdefs.h >>conftest.$ac_ext
    27794 cat >>conftest.$ac_ext <<_ACEOF
    27795 /* end confdefs.h.  */
    27796 void $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
    27805 int
    27806 main ()
    27807 {
    27808 $cfuncdaxpy()
    27809   ;
    27810   return 0;
    27811 }
    27812 _ACEOF
    27813 rm -f conftest.$ac_objext conftest$ac_exeext
    27814 if { (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
    27836 else
    27837   echo "$as_me: failed program was:" >&5
    27838 sed 's/^/| /' conftest.$ac_ext >&5
    27839 
    27840 flink_try=no
    27841 fi
    27842 rm -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
    27848 echo "${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
    27857 cat confdefs.h >>conftest.$ac_ext
    27858 cat >>conftest.$ac_ext <<_ACEOF
    27859 /* end confdefs.h.  */
    27860 void $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
    27869 int
    27870 main ()
    27871 {
    27872 $cfuncdaxpy()
    27873   ;
    27874   return 0;
    27875 }
    27876 _ACEOF
    27877 rm -f conftest.$ac_objext conftest$ac_exeext
    27878 if { (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
    27903 echo "${ECHO_T}yes: $use_blas" >&6
    27904 
    27905 
    27906 else
    27907   echo "$as_me: failed program was:" >&5
    27908 sed 's/^/| /' conftest.$ac_ext >&5
    27909 
    27910 LIBS="$flink_save_libs"
    27911                      echo "$as_me:$LINENO: result: no" >&5
    27912 echo "${ECHO_T}no" >&6
    27913 fi
    27914 rm -f conftest.err conftest.$ac_objext \
    27915       conftest$ac_exeext conftest.$ac_ext
    27916       else
    27917         echo "$as_me:$LINENO: result: no" >&5
    27918 echo "${ECHO_T}no" >&6
    27919       fi
    27920     fi
    27921     ;;
    27922   cc|cpp)
    27923     ac_ext=f
    27924 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    27925 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27926 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    27927 case $ac_cv_f77_mangling in
    27928   upper*) ac_val="DAXPY" ;;
    27929   lower*) ac_val="daxpy" ;;
    27930   *)      ac_val="unknown" ;;
    27931 esac
    27932 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    27933 
    27934 cfuncdaxpy="$ac_val"
    27935 
    27936 ac_ext=c
    27937 ac_cpp='$CPP $CPPFLAGS'
    27938 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    27939 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    27940 ac_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
    27948 cat confdefs.h >>conftest.$ac_ext
    27949 cat >>conftest.$ac_ext <<_ACEOF
    27950 /* end confdefs.h.  */
    27951 extern "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
    27960 int
    27961 main ()
    27962 {
    27963 $cfuncdaxpy()
    27964   ;
    27965   return 0;
    27966 }
    27967 _ACEOF
    27968 rm -f conftest.$ac_objext conftest$ac_exeext
    27969 if { (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
    27991 else
    27992   echo "$as_me: failed program was:" >&5
    27993 sed 's/^/| /' conftest.$ac_ext >&5
    27994 
    27995 flink_try=no
    27996 fi
    27997 rm -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
    28003 echo "${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
    28012 cat confdefs.h >>conftest.$ac_ext
    28013 cat >>conftest.$ac_ext <<_ACEOF
    28014 /* end confdefs.h.  */
    28015 extern "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
    28024 int
    28025 main ()
    28026 {
    28027 $cfuncdaxpy()
    28028   ;
    28029   return 0;
    28030 }
    28031 _ACEOF
    28032 rm -f conftest.$ac_objext conftest$ac_exeext
    28033 if { (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
    28058 echo "${ECHO_T}yes: $use_blas" >&6
    28059 
    28060 
    28061 else
    28062   echo "$as_me: failed program was:" >&5
    28063 sed 's/^/| /' conftest.$ac_ext >&5
    28064 
    28065 LIBS="$flink_save_libs"
    28066                      echo "$as_me:$LINENO: result: no" >&5
    28067 echo "${ECHO_T}no" >&6
    28068 fi
    28069 rm -f conftest.err conftest.$ac_objext \
    28070       conftest$ac_exeext conftest.$ac_ext
    28071       else
    28072         echo "$as_me:$LINENO: result: no" >&5
    28073 echo "${ECHO_T}no" >&6
    28074       fi
    28075     fi
    28076     ;;
    28077 esac
    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
    28087 echo $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
    28096 cat confdefs.h >>conftest.$ac_ext
    28097 cat >>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
    28108 int
    28109 main ()
    28110 {
    28111       call daxpy
    28112   ;
    28113   return 0;
    28114 }
    28115 _ACEOF
    28116 rm -f conftest.$ac_objext conftest$ac_exeext
    28117 if { (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
    28143 echo "${ECHO_T}yes: $use_blas" >&6
    28144 
    28145 else
    28146   echo "$as_me: failed program was:" >&5
    28147 sed 's/^/| /' conftest.$ac_ext >&5
    28148 
    28149 echo "$as_me:$LINENO: result: no" >&5
    28150 echo "${ECHO_T}no" >&6
    28151 fi
    28152 rm -f conftest.err conftest.$ac_objext \
    28153       conftest$ac_exeext conftest.$ac_ext
    28154     ;;
    28155   c)
    28156     ac_ext=f
    28157 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    28158 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28159 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    28160 case $ac_cv_f77_mangling in
    28161   upper*) ac_val="DAXPY" ;;
    28162   lower*) ac_val="daxpy" ;;
    28163   *)      ac_val="unknown" ;;
    28164 esac
    28165 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    28166 
    28167 cfuncdaxpy="$ac_val"
    28168 
    28169 ac_ext=c
    28170 ac_cpp='$CPP $CPPFLAGS'
    28171 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    28172 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28173 ac_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
    28181 cat confdefs.h >>conftest.$ac_ext
    28182 cat >>conftest.$ac_ext <<_ACEOF
    28183 /* end confdefs.h.  */
    28184 void $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
    28193 int
    28194 main ()
    28195 {
    28196 $cfuncdaxpy()
    28197   ;
    28198   return 0;
    28199 }
    28200 _ACEOF
    28201 rm -f conftest.$ac_objext conftest$ac_exeext
    28202 if { (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
    28224 else
    28225   echo "$as_me: failed program was:" >&5
    28226 sed 's/^/| /' conftest.$ac_ext >&5
    28227 
    28228 flink_try=no
    28229 fi
    28230 rm -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
    28239 echo "${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
    28248 cat confdefs.h >>conftest.$ac_ext
    28249 cat >>conftest.$ac_ext <<_ACEOF
    28250 /* end confdefs.h.  */
    28251 void $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
    28260 int
    28261 main ()
    28262 {
    28263 $cfuncdaxpy()
    28264   ;
    28265   return 0;
    28266 }
    28267 _ACEOF
    28268 rm -f conftest.$ac_objext conftest$ac_exeext
    28269 if { (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
    28297 echo "${ECHO_T}yes: $use_blas" >&6
    28298 
    28299 
    28300 else
    28301   echo "$as_me: failed program was:" >&5
    28302 sed 's/^/| /' conftest.$ac_ext >&5
    28303 
    28304 LIBS="$flink_save_libs"
    28305                      echo "$as_me:$LINENO: result: no" >&5
    28306 echo "${ECHO_T}no" >&6
    28307 fi
    28308 rm -f conftest.err conftest.$ac_objext \
    28309       conftest$ac_exeext conftest.$ac_ext
    28310       else
    28311         echo "$as_me:$LINENO: result: no" >&5
    28312 echo "${ECHO_T}no" >&6
    28313       fi
    28314     fi
    28315     ;;
    28316   cc|cpp)
    28317     ac_ext=f
    28318 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    28319 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28320 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    28321 case $ac_cv_f77_mangling in
    28322   upper*) ac_val="DAXPY" ;;
    28323   lower*) ac_val="daxpy" ;;
    28324   *)      ac_val="unknown" ;;
    28325 esac
    28326 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    28327 
    28328 cfuncdaxpy="$ac_val"
    28329 
    28330 ac_ext=c
    28331 ac_cpp='$CPP $CPPFLAGS'
    28332 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    28333 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28334 ac_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
    28342 cat confdefs.h >>conftest.$ac_ext
    28343 cat >>conftest.$ac_ext <<_ACEOF
    28344 /* end confdefs.h.  */
    28345 extern "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
    28354 int
    28355 main ()
    28356 {
    28357 $cfuncdaxpy()
    28358   ;
    28359   return 0;
    28360 }
    28361 _ACEOF
    28362 rm -f conftest.$ac_objext conftest$ac_exeext
    28363 if { (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
    28385 else
    28386   echo "$as_me: failed program was:" >&5
    28387 sed 's/^/| /' conftest.$ac_ext >&5
    28388 
    28389 flink_try=no
    28390 fi
    28391 rm -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
    28400 echo "${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
    28409 cat confdefs.h >>conftest.$ac_ext
    28410 cat >>conftest.$ac_ext <<_ACEOF
    28411 /* end confdefs.h.  */
    28412 extern "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
    28421 int
    28422 main ()
    28423 {
    28424 $cfuncdaxpy()
    28425   ;
    28426   return 0;
    28427 }
    28428 _ACEOF
    28429 rm -f conftest.$ac_objext conftest$ac_exeext
    28430 if { (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
    28458 echo "${ECHO_T}yes: $use_blas" >&6
    28459 
    28460 
    28461 else
    28462   echo "$as_me: failed program was:" >&5
    28463 sed 's/^/| /' conftest.$ac_ext >&5
    28464 
    28465 LIBS="$flink_save_libs"
    28466                      echo "$as_me:$LINENO: result: no" >&5
    28467 echo "${ECHO_T}no" >&6
    28468 fi
    28469 rm -f conftest.err conftest.$ac_objext \
    28470       conftest$ac_exeext conftest.$ac_ext
    28471       else
    28472         echo "$as_me:$LINENO: result: no" >&5
    28473 echo "${ECHO_T}no" >&6
    28474       fi
    28475     fi
    28476     ;;
    28477 esac
    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
    28485 echo $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
    28494 cat confdefs.h >>conftest.$ac_ext
    28495 cat >>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
    28506 int
    28507 main ()
    28508 {
    28509       call daxpy
    28510   ;
    28511   return 0;
    28512 }
    28513 _ACEOF
    28514 rm -f conftest.$ac_objext conftest$ac_exeext
    28515 if { (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
    28541 echo "${ECHO_T}yes: $use_blas" >&6
    28542 
    28543 else
    28544   echo "$as_me: failed program was:" >&5
    28545 sed 's/^/| /' conftest.$ac_ext >&5
    28546 
    28547 echo "$as_me:$LINENO: result: no" >&5
    28548 echo "${ECHO_T}no" >&6
    28549 fi
    28550 rm -f conftest.err conftest.$ac_objext \
    28551       conftest$ac_exeext conftest.$ac_ext
    28552     ;;
    28553   c)
    28554     ac_ext=f
    28555 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    28556 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28557 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    28558 case $ac_cv_f77_mangling in
    28559   upper*) ac_val="DAXPY" ;;
    28560   lower*) ac_val="daxpy" ;;
    28561   *)      ac_val="unknown" ;;
    28562 esac
    28563 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    28564 
    28565 cfuncdaxpy="$ac_val"
    28566 
    28567 ac_ext=c
    28568 ac_cpp='$CPP $CPPFLAGS'
    28569 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    28570 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28571 ac_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
    28579 cat confdefs.h >>conftest.$ac_ext
    28580 cat >>conftest.$ac_ext <<_ACEOF
    28581 /* end confdefs.h.  */
    28582 void $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
    28591 int
    28592 main ()
    28593 {
    28594 $cfuncdaxpy()
    28595   ;
    28596   return 0;
    28597 }
    28598 _ACEOF
    28599 rm -f conftest.$ac_objext conftest$ac_exeext
    28600 if { (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
    28622 else
    28623   echo "$as_me: failed program was:" >&5
    28624 sed 's/^/| /' conftest.$ac_ext >&5
    28625 
    28626 flink_try=no
    28627 fi
    28628 rm -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
    28637 echo "${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
    28646 cat confdefs.h >>conftest.$ac_ext
    28647 cat >>conftest.$ac_ext <<_ACEOF
    28648 /* end confdefs.h.  */
    28649 void $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
    28658 int
    28659 main ()
    28660 {
    28661 $cfuncdaxpy()
    28662   ;
    28663   return 0;
    28664 }
    28665 _ACEOF
    28666 rm -f conftest.$ac_objext conftest$ac_exeext
    28667 if { (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
    28695 echo "${ECHO_T}yes: $use_blas" >&6
    28696 
    28697 
    28698 else
    28699   echo "$as_me: failed program was:" >&5
    28700 sed 's/^/| /' conftest.$ac_ext >&5
    28701 
    28702 LIBS="$flink_save_libs"
    28703                      echo "$as_me:$LINENO: result: no" >&5
    28704 echo "${ECHO_T}no" >&6
    28705 fi
    28706 rm -f conftest.err conftest.$ac_objext \
    28707       conftest$ac_exeext conftest.$ac_ext
    28708       else
    28709         echo "$as_me:$LINENO: result: no" >&5
    28710 echo "${ECHO_T}no" >&6
    28711       fi
    28712     fi
    28713     ;;
    28714   cc|cpp)
    28715     ac_ext=f
    28716 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    28717 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28718 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    28719 case $ac_cv_f77_mangling in
    28720   upper*) ac_val="DAXPY" ;;
    28721   lower*) ac_val="daxpy" ;;
    28722   *)      ac_val="unknown" ;;
    28723 esac
    28724 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
    28725 
    28726 cfuncdaxpy="$ac_val"
    28727 
    28728 ac_ext=c
    28729 ac_cpp='$CPP $CPPFLAGS'
    28730 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    28731 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    28732 ac_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
    28740 cat confdefs.h >>conftest.$ac_ext
    28741 cat >>conftest.$ac_ext <<_ACEOF
    28742 /* end confdefs.h.  */
    28743 extern "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
    28752 int
    28753 main ()
    28754 {
    28755 $cfuncdaxpy()
    28756   ;
    28757   return 0;
    28758 }
    28759 _ACEOF
    28760 rm -f conftest.$ac_objext conftest$ac_exeext
    28761 if { (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
    28783 else
    28784   echo "$as_me: failed program was:" >&5
    28785 sed 's/^/| /' conftest.$ac_ext >&5
    28786 
    28787 flink_try=no
    28788 fi
    28789 rm -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
    28798 echo "${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
    28807 cat confdefs.h >>conftest.$ac_ext
    28808 cat >>conftest.$ac_ext <<_ACEOF
    28809 /* end confdefs.h.  */
    28810 extern "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
    28819 int
    28820 main ()
    28821 {
    28822 $cfuncdaxpy()
    28823   ;
    28824   return 0;
    28825 }
    28826 _ACEOF
    28827 rm -f conftest.$ac_objext conftest$ac_exeext
    28828 if { (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
    28856 echo "${ECHO_T}yes: $use_blas" >&6
    28857 
    28858 
    28859 else
    28860   echo "$as_me: failed program was:" >&5
    28861 sed 's/^/| /' conftest.$ac_ext >&5
    28862 
    28863 LIBS="$flink_save_libs"
    28864                      echo "$as_me:$LINENO: result: no" >&5
    28865 echo "${ECHO_T}no" >&6
    28866 fi
    28867 rm -f conftest.err conftest.$ac_objext \
    28868       conftest$ac_exeext conftest.$ac_ext
    28869       else
    28870         echo "$as_me:$LINENO: result: no" >&5
    28871 echo "${ECHO_T}no" >&6
    28872       fi
    28873     fi
    28874     ;;
    28875 esac
    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
    28884 fi
    28885 
    28886 if test "x$use_blas" = xBUILD ; then
    28887 
    28888 echo "$as_me:$LINENO: checking for COIN-OR package Blas" >&5
    28889 echo $ECHO_N "checking for COIN-OR package Blas... $ECHO_C" >&6
    28890 
    28891 coin_has_blas=notGiven
    28892 
    28893 # check if user wants to skip package in any case
    28894 if 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
    28900 fi
    28901 
    28902 BLAS_LIBS=
    28903 BLAS_CFLAGS=
    28904 BLAS_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
    28923 if test $coin_has_blas != skipping; then
    28924 
    28925 # Check whether --with-m4_tolower(Blas)-lib or --without-m4_tolower(Blas)-lib was given.
    28926 if 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 
    28944 fi;
    28945 fi
    28946 
    28947 if test $coin_has_blas != skipping; then
    28948 
    28949 # Check whether --with-m4_tolower(Blas)-incdir or --without-m4_tolower(Blas)-incdir was given.
    28950 if 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 
    28965 fi;
    28966 fi
    28967 
    28968 if test $coin_has_blas != skipping; then
    28969 
    28970 # Check whether --with-m4_tolower(Blas)-datadir or --without-m4_tolower(Blas)-datadir was given.
    28971 if 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 
    28984 fi;
    28985 fi
    28986 
    28987 if 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 
    28999 if 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
    29015 echo "${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
    29036 echo "${ECHO_T}not given: $BLAS_PKG_ERRORS" >&6
    29037 
    29038   fi
    29039 else
    29040   { { echo "$as_me:$LINENO: error: \"Cannot check for existance of module Blas without pkg-config\"" >&5
    29041 echo "$as_me: error: \"Cannot check for existance of module Blas without pkg-config\"" >&2;}
    29042    { (exit 1); exit 1; }; }
    29043 fi
    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
    29054 echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
    29055 
    29056 echo "$as_me:$LINENO: checking for COIN-OR package Blas (fallback)" >&5
    29057 echo $ECHO_N "checking for COIN-OR package Blas (fallback)... $ECHO_C" >&6
    29058 
    29059 coin_has_blas=notGiven
    29060 BLAS_LIBS=
    29061 BLAS_LIBS_INSTALLED=
    29062 BLAS_CFLAGS=
    29063 BLAS_CFLAGS_INSTALLED=
    29064 BLAS_DATA=
    29065 BLAS_DATA_INSTALLED=
    29066 
    29067 # initial list of dependencies is "coinblas", but we need to filter out version number specifications (= x, <= x, >= x)
    29068 projtoprocess="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
    29074 allproj=""
    29075 allpcfiles=""
    29076 allpcifiles=""
    29077 while 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
    29092 echo "$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
    29121 echo "${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 
    29148 done
    29149 
    29150 if 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
    29245 echo "${ECHO_T}yes" >&6
    29246 
    29247 cat >>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 
    29271 fi
    29272 
    29273 
    29274 
    29275 if test $coin_has_blas != notGiven &&
    29276                 test $coin_has_blas != skipping; then
    29277   COIN_HAS_BLAS_TRUE=
    29278   COIN_HAS_BLAS_FALSE='#'
    29279 else
    29280   COIN_HAS_BLAS_TRUE='#'
    29281   COIN_HAS_BLAS_FALSE=
    29282 fi
    29283 
    29284 
    29285 
    29286   fi
    29287 
    29288 else
    29289   echo "$as_me:$LINENO: result: $coin_has_blas" >&5
    29290 echo "${ECHO_T}$coin_has_blas" >&6
    29291 fi
    29292 
    29293 if test $coin_has_blas != skipping &&
    29294    test $coin_has_blas != notGiven ; then
    29295 
    29296 cat >>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.
    29302 if test "${enable_interpackage_dependencies+set}" = set; then
    29303   enableval="$enable_interpackage_dependencies"
    29304 
    29305 else
    29306   enable_interpackage_dependencies=yes
    29307 fi;
    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
    29324 echo "$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
    29328 echo "$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
    29332 echo "$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
    29336 echo "$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
    29340 echo "$as_me: Blas CFLAGS are $BLAS_CFLAGS" >&6;}
    29341     fi
    29342 
    29343       { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
    29344 echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
    29345       { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
    29346 echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
    29347       { echo "$as_me:$LINENO: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&5
    29348 echo "$as_me: ClpLib DEPENDENCIES are $CLPLIB_DEPENDENCIES" >&6;}
    29349 
    29350   fi
    29351 fi
    29352 
    29353 # Define the Makefile conditional
    29354 
    29355 
    29356 if test $coin_has_blas != notGiven &&
    29357                 test $coin_has_blas != skipping; then
    29358   COIN_HAS_BLAS_TRUE=
    29359   COIN_HAS_BLAS_FALSE='#'
    29360 else
    29361   COIN_HAS_BLAS_TRUE='#'
    29362   COIN_HAS_BLAS_FALSE=
    29363 fi
    29364 
    29365 
    29366 
    29367 
    29368 elif test "x$use_blas" != x && test "$use_blas" != no; then
    29369   coin_has_blas=yes
    29370 
    29371 
    29372 if test 0 = 0; then
    29373   COIN_HAS_BLAS_TRUE=
    29374   COIN_HAS_BLAS_FALSE='#'
    29375 else
    29376   COIN_HAS_BLAS_TRUE='#'
    29377   COIN_HAS_BLAS_FALSE=
    29378 fi
    29379 
    29380 
    29381 cat >>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 
    29397 else
    29398   coin_has_blas=no
    29399 
    29400 
    29401 if test 0 = 1; then
    29402   COIN_HAS_BLAS_TRUE=
    29403   COIN_HAS_BLAS_FALSE='#'
    29404 else
    29405   COIN_HAS_BLAS_TRUE='#'
    29406   COIN_HAS_BLAS_FALSE=
    29407 fi
    29408 
    29409 fi
    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
    29422 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
    29423 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    29424 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
    29425 
    29426   echo "$as_me:$LINENO: checking whether user-supplied WSMP library \"$use_wsmp\" works" >&5
    29427 echo $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
    29433 rm -f conftest.$ac_objext conftest$ac_exeext
    29434 if { (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
    29456 echo "${ECHO_T}yes" >&6
    29457 else
    29458   echo "$as_me: failed program was:" >&5
    29459 sed 's/^/| /' conftest.$ac_ext >&5
    29460 
    29461 echo "$as_me:$LINENO: result: no" >&5
    29462 echo "${ECHO_T}no" >&6
    29463                { { echo "$as_me:$LINENO: error: WSMP library $use_wsmp does not seem to work" >&5
     23181  if test "x$defval" = "x"; then
     23182    { { echo "$as_me:$LINENO: error: WSMP library $use_wsmp does not seem to work" >&5
    2946423183echo "$as_me: error: WSMP library $use_wsmp does not seem to work" >&2;}
    2946523184   { (exit 1); exit 1; }; }
    29466 fi
    29467 rm -f conftest.err conftest.$ac_objext \
    29468       conftest$ac_exeext conftest.$ac_ext
    29469   ac_ext=c
    29470 ac_cpp='$CPP $CPPFLAGS'
    29471 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    29472 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    29473 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    29474 
    29475   LIBS="$coin_save_LIBS"
     23185  fi
    2947623186
    2947723187
    2947823188cat >>confdefs.h <<_ACEOF
    29479 #define COIN_HAS_WSMP 1
     23189#define WSSMP_BARRIER $defval
    2948023190_ACEOF
    2948123191
    29482 
    29483   CLPLIB_LIBS="$use_wsmp $CLPLIB_LIBS"
    29484   CLPLIB_LIBS_INSTALLED="$use_wsmp $CLPLIB_LIBS_INSTALLED"
    29485   CLPLIB_PCLIBS="$use_wsmp $CLPLIB_PCLIBS"
    29486 fi
    29487 
    29488 
    29489 if test "$use_wsmp" != no; then
    29490   COIN_HAS_WSMP_TRUE=
    29491   COIN_HAS_WSMP_FALSE='#'
    29492 else
    29493   COIN_HAS_WSMP_TRUE='#'
    29494   COIN_HAS_WSMP_FALSE=
    29495 fi
    29496 
     23192fi
    2949723193
    2949823194#############################################################################
     
    2961023306   builtin and then its argument prototype would still apply.  */
    2961123307char 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
    2962023308int
    2962123309main ()
     
    2967323361   builtin and then its argument prototype would still apply.  */
    2967423362char 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
    2968323363int
    2968423364main ()
     
    2975823438   builtin and then its argument prototype would still apply.  */
    2975923439char 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
    2976823440int
    2976923441main ()
     
    3034924021Usually this means the macro was only invoked conditionally." >&5
    3035024022echo "$as_me: error: conditional \"COIN_HAS_NETLIB\" was never defined.
    30351 Usually this means the macro was only invoked conditionally." >&2;}
    30352    { (exit 1); exit 1; }; }
    30353 fi
    30354 if 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.
    30356 Usually this means the macro was only invoked conditionally." >&5
    30357 echo "$as_me: error: conditional \"COIN_HAS_AMD\" was never defined.
    30358 Usually this means the macro was only invoked conditionally." >&2;}
    30359    { (exit 1); exit 1; }; }
    30360 fi
    30361 if 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.
    30363 Usually this means the macro was only invoked conditionally." >&5
    30364 echo "$as_me: error: conditional \"COIN_HAS_CHOLMOD\" was never defined.
    30365 Usually this means the macro was only invoked conditionally." >&2;}
    30366    { (exit 1); exit 1; }; }
    30367 fi
    30368 if 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.
    30370 Usually this means the macro was only invoked conditionally." >&5
    30371 echo "$as_me: error: conditional \"COIN_HAS_GLPK\" was never defined.
    30372 Usually this means the macro was only invoked conditionally." >&2;}
    30373    { (exit 1); exit 1; }; }
    30374 fi
    30375 if 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.
    30377 Usually this means the macro was only invoked conditionally." >&5
    30378 echo "$as_me: error: conditional \"COIN_HAS_GLPK\" was never defined.
    30379 Usually this means the macro was only invoked conditionally." >&2;}
    30380    { (exit 1); exit 1; }; }
    30381 fi
    30382 if 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.
    30384 Usually this means the macro was only invoked conditionally." >&5
    30385 echo "$as_me: error: conditional \"COIN_HAS_GLPK\" was never defined.
    30386 Usually this means the macro was only invoked conditionally." >&2;}
    30387    { (exit 1); exit 1; }; }
    30388 fi
    30389 if 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.
    30391 Usually this means the macro was only invoked conditionally." >&5
    30392 echo "$as_me: error: conditional \"COIN_HAS_MUMPS\" was never defined.
    30393 Usually this means the macro was only invoked conditionally." >&2;}
    30394    { (exit 1); exit 1; }; }
    30395 fi
    30396 if 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.
    30398 Usually this means the macro was only invoked conditionally." >&5
    30399 echo "$as_me: error: conditional \"COIN_HAS_MUMPS\" was never defined.
    30400 Usually this means the macro was only invoked conditionally." >&2;}
    30401    { (exit 1); exit 1; }; }
    30402 fi
    30403 if 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.