Changeset 2341


Ignore:
Timestamp:
Oct 12, 2018 10:48:02 PM (7 months ago)
Author:
lou
Message:

Fix up some external library checks in configure.ac now that COIN_CHK_LIB has a
functioning link check.

Location:
branches/autotools-update/Clp
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/autotools-update/Clp/configure

    r2340 r2341  
    671671COIN_HAS_ASL_FALSE
    672672COIN_HAS_ASL_TRUE
     673COIN_HAS_BLAS_FALSE
     674COIN_HAS_BLAS_TRUE
    673675COIN_HAS_WSMP_FALSE
    674676COIN_HAS_WSMP_TRUE
     
    896898with_wsmp_lflags
    897899with_wsmp_cflags
     900with_blas
     901with_blas_lflags
     902with_blas_cflags
    898903with_asl
    899904with_asl_lflags
     
    16561661                          environment. (Most often, -l specs for libraries.)
    16571662  --with-wsmp-cflags      Compiler flags for WSMP appropriate for your
     1663                          environment. (Most often, -I specs for header file
     1664                          directories.)
     1665  --with-blas             Use blas. If an argument is given, 'yes' is
     1666                          equivalent to --with-blas, 'no' is
     1667                          equivalent to --without-blas. Any other argument is
     1668                          applied as for --with-blas-lflags
     1669  --with-blas-lflags      Linker flags for blas appropriate for your
     1670                          environment. (Most often, -l specs for libraries.)
     1671  --with-blas-cflags      Compiler flags for blas appropriate for your
    16581672                          environment. (Most often, -I specs for header file
    16591673                          directories.)
     
    2211322127#############################################################################
    2211422128
    22115 # AMD from UFL
    22116 # [amd.h] [amd_defaults]
    22117 
     22129# AMD and CHOLMOD from UFL. Glpk is an alternative source for amd. CHOLMOD
     22130# doc'n claims it requires METIS, but apparently that's not necessary for the
     22131# version distributed with Fedora.
     22132
     22133# amd.h
    2211822134
    2211922135  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package AMD" >&5
     
    2219622212      * )
    2219722213        coin_has_amd=yes
    22198         amd_libs=$withval
     22214        amd_lflags=$withval
    2219922215        ;;
    2220022216    esac
     
    2221422230           * )
    2221522231             coin_has_amd=yes
    22216              amd_libs=$withval
     22232             amd_lflags=$withval
    2221722233             ;;
    2221822234         esac
     
    2228022296  esac
    2228122297
    22282 # The final value of coin_has_prim will be yes or skipping.  Skipping means
    22283 # the user said `don't use.' Yes means we have something, from the user or
    22284 # macro parameters or invented. Note that we haven't run a useability test!
     22298# At this point, coin_has_prim is yes or skipping.  Time to run a link check,
     22299# if we have a function (amd_defaults). Use whatever we've collected for lflags, plus
     22300# other libraries () as the other libraries parameter to AC_SEARCH_LIBS,
     22301# leaving the library parameter blank.
     22302
     22303  if test $coin_has_amd != skipping ; then
     22304    ac_save_LIBS=$LIBS
     22305       LIBS="$amd_lflags "
     22306       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     22307/* end confdefs.h.  */
     22308#ifdef __cplusplus
     22309             extern "C"
     22310           #endif
     22311           void amd_defaults();
     22312#ifdef F77_DUMMY_MAIN
     22313
     22314#  ifdef __cplusplus
     22315     extern "C"
     22316#  endif
     22317   int F77_DUMMY_MAIN() { return 1; }
     22318
     22319#endif
     22320int
     22321main ()
     22322{
     22323amd_defaults()
     22324  ;
     22325  return 0;
     22326}
     22327_ACEOF
     22328if ac_fn_cxx_try_link "$LINENO"; then :
     22329
     22330else
     22331  coin_has_amd=no
     22332fi
     22333rm -f core conftest.err conftest.$ac_objext \
     22334    conftest$ac_exeext conftest.$ac_ext
     22335       LIBS=$ac_save_LIBS
     22336  fi
     22337
     22338# The final value of coin_has_prim will be yes, no, or skipping. No means that
     22339# the link check failed. Yes means that we passed the link check, or no link
     22340# check was performed. Skipping means the user said `don't use.'
    2228522341
    2228622342# Change the test to enable / disable debugging output
     
    2230922365  fi
    2231022366
    22311 # Possibilities are `yes' or `skipping'. Normalise to `yes' or `no'.
     22367# Possibilities are `yes', `no', or `skipping'. Normalise to `yes' or `no'.
    2231222368
    2231322369  if test "$coin_has_amd" != yes ; then
     
    2234322399
    2234422400
    22345 # CHOLMOD from UFL (requires AMD).
    22346 # [cholmod.h] [cholmod_start]
     22401# CHOLMOD from UFL
     22402# Requires AMD, but apparently not for a link check with dynamic libraries.
     22403# cholmod.h
    2234722404
    2234822405
     
    2242622483      * )
    2242722484        coin_has_cholmod=yes
    22428         cholmod_libs=$withval
     22485        cholmod_lflags=$withval
    2242922486        ;;
    2243022487    esac
     
    2244422501           * )
    2244522502             coin_has_cholmod=yes
    22446              cholmod_libs=$withval
     22503             cholmod_lflags=$withval
    2244722504             ;;
    2244822505         esac
     
    2251022567  esac
    2251122568
    22512 # The final value of coin_has_prim will be yes or skipping.  Skipping means
    22513 # the user said `don't use.' Yes means we have something, from the user or
    22514 # macro parameters or invented. Note that we haven't run a useability test!
     22569# At this point, coin_has_prim is yes or skipping.  Time to run a link check,
     22570# if we have a function (cholmod_start). Use whatever we've collected for lflags, plus
     22571# other libraries () as the other libraries parameter to AC_SEARCH_LIBS,
     22572# leaving the library parameter blank.
     22573
     22574  if test $coin_has_cholmod != skipping ; then
     22575    ac_save_LIBS=$LIBS
     22576       LIBS="$cholmod_lflags "
     22577       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     22578/* end confdefs.h.  */
     22579#ifdef __cplusplus
     22580             extern "C"
     22581           #endif
     22582           void cholmod_start();
     22583#ifdef F77_DUMMY_MAIN
     22584
     22585#  ifdef __cplusplus
     22586     extern "C"
     22587#  endif
     22588   int F77_DUMMY_MAIN() { return 1; }
     22589
     22590#endif
     22591int
     22592main ()
     22593{
     22594cholmod_start()
     22595  ;
     22596  return 0;
     22597}
     22598_ACEOF
     22599if ac_fn_cxx_try_link "$LINENO"; then :
     22600
     22601else
     22602  coin_has_cholmod=no
     22603fi
     22604rm -f core conftest.err conftest.$ac_objext \
     22605    conftest$ac_exeext conftest.$ac_ext
     22606       LIBS=$ac_save_LIBS
     22607  fi
     22608
     22609# The final value of coin_has_prim will be yes, no, or skipping. No means that
     22610# the link check failed. Yes means that we passed the link check, or no link
     22611# check was performed. Skipping means the user said `don't use.'
    2251522612
    2251622613# Change the test to enable / disable debugging output
     
    2253922636  fi
    2254022637
    22541 # Possibilities are `yes' or `skipping'. Normalise to `yes' or `no'.
     22638# Possibilities are `yes', `no', or `skipping'. Normalise to `yes' or `no'.
    2254222639
    2254322640  if test "$coin_has_cholmod" != yes ; then
     
    2316123258
    2316223259
    23163   dflt_action=no
     23260  dflt_action=yes
    2316423261
    2316523262# Initialize variables for the primary library.
     
    2318723284      * )
    2318823285        coin_has_wsmp=yes
    23189         wsmp_libs=$withval
     23286        wsmp_lflags=$withval
    2319023287        ;;
    2319123288    esac
     
    2320523302           * )
    2320623303             coin_has_wsmp=yes
    23207              wsmp_libs=$withval
     23304             wsmp_lflags=$withval
    2320823305             ;;
    2320923306         esac
     
    2327723374  esac
    2327823375
    23279 # The final value of coin_has_prim will be yes or skipping.  Skipping means
    23280 # the user said `don't use.' Yes means we have something, from the user or
    23281 # macro parameters or invented. Note that we haven't run a useability test!
     23376# At this point, coin_has_prim is yes or skipping.  Time to run a link check,
     23377# if we have a function (no). Use whatever we've collected for lflags, plus
     23378# other libraries () as the other libraries parameter to AC_SEARCH_LIBS,
     23379# leaving the library parameter blank.
     23380
     23381  if test $coin_has_wsmp != skipping ; then
     23382    ac_save_LIBS=$LIBS
     23383       LIBS="$wsmp_lflags "
     23384       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23385/* end confdefs.h.  */
     23386#ifdef __cplusplus
     23387             extern "C"
     23388           #endif
     23389           void no();
     23390#ifdef F77_DUMMY_MAIN
     23391
     23392#  ifdef __cplusplus
     23393     extern "C"
     23394#  endif
     23395   int F77_DUMMY_MAIN() { return 1; }
     23396
     23397#endif
     23398int
     23399main ()
     23400{
     23401no()
     23402  ;
     23403  return 0;
     23404}
     23405_ACEOF
     23406if ac_fn_cxx_try_link "$LINENO"; then :
     23407
     23408else
     23409  coin_has_wsmp=no
     23410fi
     23411rm -f core conftest.err conftest.$ac_objext \
     23412    conftest$ac_exeext conftest.$ac_ext
     23413       LIBS=$ac_save_LIBS
     23414  fi
     23415
     23416# The final value of coin_has_prim will be yes, no, or skipping. No means that
     23417# the link check failed. Yes means that we passed the link check, or no link
     23418# check was performed. Skipping means the user said `don't use.'
    2328223419
    2328323420# Change the test to enable / disable debugging output
     
    2330623443  fi
    2330723444
    23308 # Possibilities are `yes' or `skipping'. Normalise to `yes' or `no'.
     23445# Possibilities are `yes', `no', or `skipping'. Normalise to `yes' or `no'.
    2330923446
    2331023447  if test "$coin_has_wsmp" != yes ; then
     
    2334123478
    2334223479if test "$use_wsmp" = yes ; then
    23343   # AC_COIN_CHK_PKG_BLAS(ClpLib)
     23480
     23481
     23482
     23483  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package BLAS" >&5
     23484$as_echo_n "checking for package BLAS... " >&6; }
     23485
     23486# Make sure the necessary variables exist for each client package.
     23487
     23488
     23489
     23490
     23491
     23492
     23493# Set up command line arguments with DEF_PRIM_ARGS and give FIND_PRIM_PKG
     23494# a chance, just in case blas.pc exists. The result (coin_has_blas) will
     23495# be one of yes (either the user specified something or pkgconfig found
     23496# something), no (user specified nothing and pkgconfig found nothing) or
     23497# skipping (user said do not use). We'll also have variables blas_lflags,
     23498# blas_cflags, blas_data, and blas_pcfiles.
     23499
     23500
     23501
     23502
     23503
     23504# Check whether --with-blas was given.
     23505if test "${with_blas+set}" = set; then :
     23506  withval=$with_blas;
     23507fi
     23508
     23509
     23510
     23511# Check whether --with-blas-lflags was given.
     23512if test "${with_blas_lflags+set}" = set; then :
     23513  withval=$with_blas_lflags;
     23514fi
     23515
     23516
     23517
     23518# Check whether --with-blas-cflags was given.
     23519if test "${with_blas_cflags+set}" = set; then :
     23520  withval=$with_blas_cflags;
     23521fi
     23522
     23523
     23524
     23525
     23526
     23527
     23528
     23529  dflt_action=yes
     23530
     23531# Initialize variables for the primary package.
     23532
     23533  coin_has_blas=noInfo
     23534  blas_lflags=
     23535  blas_cflags=
     23536  blas_data=
     23537  blas_pcfiles=
     23538
     23539# --with-prim is always present. If the client specified dataonly, its value
     23540# is assigned to prim_data.
     23541
     23542  withval=$with_blas
     23543  if test -n "$withval" ; then
     23544    case "$withval" in
     23545      no )
     23546        coin_has_blas=skipping
     23547        ;;
     23548      yes )
     23549        coin_has_blas=requested
     23550        ;;
     23551      build )
     23552        coin_has_blas=build
     23553        ;;
     23554      * )
     23555        coin_has_blas=yes
     23556        blas_lflags=$withval
     23557        ;;
     23558    esac
     23559  fi
     23560
     23561# --with-prim-libs and --with-prim-cflags are present unless the client
     23562# specified dataonly. Specifying --with-prim=no overrides the individual
     23563# options for libs and cflags.
     23564
     23565  if test "$coin_has_blas" != skipping ; then
     23566       withval=$with_blas_lflags
     23567       if test -n "$withval" ; then
     23568         case "$withval" in
     23569           build | no | yes )
     23570             as_fn_error $? "\"$withval\" is not valid here; please specify linker flags appropriate for your environment." "$LINENO" 5
     23571             ;;
     23572           * )
     23573             coin_has_blas=yes
     23574             blas_lflags=$withval
     23575             ;;
     23576         esac
     23577       fi
     23578
     23579       withval=$with_blas_cflags
     23580       if test -n "$withval" ; then
     23581         case "$withval" in
     23582           build | no | yes )
     23583             as_fn_error $? "\"$withval\" is not valid here; please specify compiler flags appropriate for your environment." "$LINENO" 5
     23584             ;;
     23585           * )
     23586             coin_has_blas=yes
     23587             blas_cflags="$withval"
     23588             ;;
     23589         esac
     23590       fi
     23591     fi
     23592
     23593# --with-prim-data will be present unless the client specified nodata.
     23594# Specifying --with-prim=no overrides the individual option for data.
     23595
     23596
     23597
     23598# At this point, coin_has_prim can be one of noInfo (no user options
     23599# specified), skipping (user said no), requested or build (user said yes
     23600# or build and gave no further guidance), or yes (user specified one or
     23601# more --with-prim options). If we're already at yes or skipping, we're
     23602# done looking.
     23603
     23604# If there are no user options (noInfo) and the default is no, we're skipping.
     23605# Otherwise, the default must be yes or build; consider the package requested.
     23606# A default action we don't recognise defaults to yes.
     23607
     23608  if test "$coin_has_blas" = noInfo ; then
     23609    case $dflt_action in
     23610      no )
     23611        coin_has_blas=skipping
     23612        ;;
     23613      build )
     23614        coin_has_blas=build
     23615        ;;
     23616      * )
     23617        coin_has_blas=requested
     23618        ;;
     23619    esac
     23620  fi
     23621
     23622# Now coin_has_prim can be one of skipping, yes, requested, or build. For
     23623# requested or build, try pkgconf, if it's available. If it's not available,
     23624# well, hope that the user knows their system and prim can be used with no
     23625# additional flags.
     23626
     23627  case $coin_has_blas in
     23628    requested | build )
     23629      if test -n "$PKG_CONFIG" ; then
     23630        if test $coin_has_blas = build ; then
     23631             pcfile=coinblas
     23632           else
     23633             pcfile=blas
     23634           fi
     23635
     23636
     23637
     23638  if test -n "$PKG_CONFIG" ; then
     23639    if PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH" $PKG_CONFIG --exists "$pcfile" ; then
     23640      BLAS_VERSIONS=`PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH" $PKG_CONFIG --modversion "$pcfile" 2>/dev/null | tr '\n' ' '`
     23641      coin_has_blas=yes
     23642           blas_data=`PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH" $PKG_CONFIG --variable=datadir $pcfile 2>/dev/null`
     23643           blas_pcfiles="$pcfile"
     23644    else
     23645      BLAS_PKG_ERRORS=`PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH" $PKG_CONFIG $pkg_short_errors --errors-to-stdout --print-errors "$pcfile"`
     23646      coin_has_blas=no
     23647    fi
     23648  else
     23649    as_fn_error $? "\"Cannot check for existence of module blas without pkgconf\"" "$LINENO" 5
     23650  fi
     23651
     23652      else
     23653        coin_has_blas=yes
     23654        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
     23655      fi
     23656      ;;
     23657    skipping | yes )
     23658      ;;
     23659    * )
     23660      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unexpected status \"$coin_has_blas\" in COIN_FIND_PRIM_PKG" >&5
     23661$as_echo "$as_me: WARNING: Unexpected status \"$coin_has_blas\" in COIN_FIND_PRIM_PKG" >&2;}
     23662      ;;
     23663  esac
     23664
     23665# The final value of coin_has_prim will be yes, no, or skipping. No means
     23666# we looked (with pkgconfig) and didn't find anything. Skipping means the
     23667# user said `don't use.' Yes means we have something, from the user or
     23668# from pkgconfig. Note that we haven't run a useability test!
     23669
     23670# Change the test to enable / disable debugging output
     23671
     23672    if test 1 = 1 ; then
     23673      { $as_echo "$as_me:${as_lineno-$LINENO}: FIND_PRIM_PKG result for blas: \"$coin_has_blas\"" >&5
     23674$as_echo "$as_me: FIND_PRIM_PKG result for blas: \"$coin_has_blas\"" >&6;}
     23675      { $as_echo "$as_me:${as_lineno-$LINENO}: Collected values for package 'blas'" >&5
     23676$as_echo "$as_me: Collected values for package 'blas'" >&6;}
     23677      { $as_echo "$as_me:${as_lineno-$LINENO}: blas_lflags is \"$blas_lflags\"" >&5
     23678$as_echo "$as_me: blas_lflags is \"$blas_lflags\"" >&6;}
     23679      { $as_echo "$as_me:${as_lineno-$LINENO}: blas_cflags is \"$blas_cflags\"" >&5
     23680$as_echo "$as_me: blas_cflags is \"$blas_cflags\"" >&6;}
     23681      { $as_echo "$as_me:${as_lineno-$LINENO}: blas_data is \"$blas_data\"" >&5
     23682$as_echo "$as_me: blas_data is \"$blas_data\"" >&6;}
     23683      { $as_echo "$as_me:${as_lineno-$LINENO}: blas_pcfiles is \"$blas_pcfiles\"" >&5
     23684$as_echo "$as_me: blas_pcfiles is \"$blas_pcfiles\"" >&6;}
     23685    fi
     23686
     23687
     23688
     23689# If FIND_PRIM_PKG found something and the user wants a link check, do it. For
     23690# a successful link check, update blas_libs just in case FLIBS was added.
     23691
     23692  if test "$coin_has_blas" = yes ; then
     23693    use_blas=
     23694
     23695  coin_save_LIBS="$LIBS"
     23696  LIBS="$blas_lflags $LIBS"
     23697   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     23698  case $ac_ext in
     23699    f)
     23700      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23701/* end confdefs.h.  */
     23702
     23703#ifdef F77_DUMMY_MAIN
     23704
     23705#  ifdef __cplusplus
     23706     extern "C"
     23707#  endif
     23708   int F77_DUMMY_MAIN() { return 1; }
     23709
     23710#endif
     23711int
     23712main ()
     23713{
     23714      call daxpy
     23715  ;
     23716  return 0;
     23717}
     23718_ACEOF
     23719if ac_fn_cxx_try_link "$LINENO"; then :
     23720  flink_try=yes
     23721else
     23722  flink_try=no
     23723fi
     23724rm -f core conftest.err conftest.$ac_objext \
     23725    conftest$ac_exeext conftest.$ac_ext
     23726      ;;
     23727    c)
     23728      coin_need_flibs=no
     23729      flink_try=no
     23730       ac_ext=f
     23731ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     23732ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23733ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     23734
     23735  case $ac_cv_f77_mangling in
     23736  upper*) ac_val="DAXPY" ;;
     23737  lower*) ac_val="daxpy" ;;
     23738  *)      ac_val="unknown" ;;
     23739esac
     23740case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     23741
     23742cfuncdaxpy="$ac_val"
     23743
     23744  ac_ext=cpp
     23745ac_cpp='$CXXCPP $CPPFLAGS'
     23746ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23747ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23748ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     23749
     23750
     23751      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     23752      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23753/* end confdefs.h.  */
     23754void $cfuncdaxpy();
     23755#ifdef F77_DUMMY_MAIN
     23756
     23757#  ifdef __cplusplus
     23758     extern "C"
     23759#  endif
     23760   int F77_DUMMY_MAIN() { return 1; }
     23761
     23762#endif
     23763int
     23764main ()
     23765{
     23766$cfuncdaxpy()
     23767  ;
     23768  return 0;
     23769}
     23770_ACEOF
     23771if ac_fn_cxx_try_link "$LINENO"; then :
     23772  flink_try=yes
     23773else
     23774  if test x"$FLIBS" != x ; then
     23775           flink_save_libs="$LIBS"
     23776           LIBS="$LIBS $FLIBS"
     23777           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23778/* end confdefs.h.  */
     23779void $cfuncdaxpy();
     23780#ifdef F77_DUMMY_MAIN
     23781
     23782#  ifdef __cplusplus
     23783     extern "C"
     23784#  endif
     23785   int F77_DUMMY_MAIN() { return 1; }
     23786
     23787#endif
     23788int
     23789main ()
     23790{
     23791$cfuncdaxpy()
     23792  ;
     23793  return 0;
     23794}
     23795_ACEOF
     23796if ac_fn_cxx_try_link "$LINENO"; then :
     23797  coin_need_flibs=yes
     23798              flink_try=yes
     23799
     23800fi
     23801rm -f core conftest.err conftest.$ac_objext \
     23802    conftest$ac_exeext conftest.$ac_ext
     23803           LIBS="$flink_save_libs"
     23804         fi
     23805
     23806
     23807fi
     23808rm -f core conftest.err conftest.$ac_objext \
     23809    conftest$ac_exeext conftest.$ac_ext
     23810      ;;
     23811    cc|cpp)
     23812      coin_need_flibs=no
     23813      flink_try=no
     23814       ac_ext=f
     23815ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     23816ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23817ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     23818
     23819  case $ac_cv_f77_mangling in
     23820  upper*) ac_val="DAXPY" ;;
     23821  lower*) ac_val="daxpy" ;;
     23822  *)      ac_val="unknown" ;;
     23823esac
     23824case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     23825
     23826cfuncdaxpy="$ac_val"
     23827
     23828  ac_ext=cpp
     23829ac_cpp='$CXXCPP $CPPFLAGS'
     23830ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23831ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23832ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     23833
     23834
     23835      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23836/* end confdefs.h.  */
     23837extern "C" {void $cfuncdaxpy();}
     23838#ifdef F77_DUMMY_MAIN
     23839
     23840#  ifdef __cplusplus
     23841     extern "C"
     23842#  endif
     23843   int F77_DUMMY_MAIN() { return 1; }
     23844
     23845#endif
     23846int
     23847main ()
     23848{
     23849$cfuncdaxpy()
     23850  ;
     23851  return 0;
     23852}
     23853_ACEOF
     23854if ac_fn_cxx_try_link "$LINENO"; then :
     23855  flink_try=yes
     23856else
     23857  if test x"$FLIBS" != x ; then
     23858           flink_save_libs="$LIBS"
     23859           LIBS="$LIBS $FLIBS"
     23860           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23861/* end confdefs.h.  */
     23862extern "C" {void $cfuncdaxpy();}
     23863#ifdef F77_DUMMY_MAIN
     23864
     23865#  ifdef __cplusplus
     23866     extern "C"
     23867#  endif
     23868   int F77_DUMMY_MAIN() { return 1; }
     23869
     23870#endif
     23871int
     23872main ()
     23873{
     23874$cfuncdaxpy()
     23875  ;
     23876  return 0;
     23877}
     23878_ACEOF
     23879if ac_fn_cxx_try_link "$LINENO"; then :
     23880  coin_need_flibs=yes
     23881              flink_try=yes
     23882
     23883fi
     23884rm -f core conftest.err conftest.$ac_objext \
     23885    conftest$ac_exeext conftest.$ac_ext
     23886           LIBS="$flink_save_libs"
     23887         fi
     23888
     23889
     23890fi
     23891rm -f core conftest.err conftest.$ac_objext \
     23892    conftest$ac_exeext conftest.$ac_ext
     23893      ;;
     23894  esac
     23895  if test $flink_try = yes ; then
     23896    if test $coin_need_flibs = no ; then
     23897       use_blas="$blas_lflags"
     23898     else
     23899       use_blas="$blas_lflags $FLIBS"
     23900     fi
     23901     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $use_blas" >&5
     23902$as_echo "yes: $use_blas" >&6; }
     23903  else
     23904    use_blas=
     23905     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     23906$as_echo "no" >&6; }
     23907  fi
     23908  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     23909
     23910  LIBS="$coin_save_LIBS"
     23911
     23912       if test -n "$use_blas" ; then
     23913         blas_lflags=$use_blas
     23914       else
     23915         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: BLAS failed to link with \"$blas_lflags\"" >&5
     23916$as_echo "$as_me: WARNING: BLAS failed to link with \"$blas_lflags\"" >&2;}
     23917       fi
     23918
     23919# If FIND_PRIM_PKG didn't find anything, try a few guesses.  Try some
     23920# specialised checks based on the host system type first.  If none of them
     23921# are applicable, or the applicable one fails, try the generic -lblas.
     23922
     23923  elif test "$coin_has_blas" = no ; then
     23924    { $as_echo "$as_me:${as_lineno-$LINENO}: result: nothing yet" >&5
     23925$as_echo "nothing yet" >&6; }
     23926    case $build in
     23927      *-sgi-*)
     23928        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BLAS in -lcomplib.sgimath" >&5
     23929$as_echo_n "checking for BLAS in -lcomplib.sgimath... " >&6; }
     23930
     23931  coin_save_LIBS="$LIBS"
     23932  LIBS="-lcomplib.sgimath $LIBS"
     23933   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     23934  case $ac_ext in
     23935    f)
     23936      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23937/* end confdefs.h.  */
     23938
     23939#ifdef F77_DUMMY_MAIN
     23940
     23941#  ifdef __cplusplus
     23942     extern "C"
     23943#  endif
     23944   int F77_DUMMY_MAIN() { return 1; }
     23945
     23946#endif
     23947int
     23948main ()
     23949{
     23950      call daxpy
     23951  ;
     23952  return 0;
     23953}
     23954_ACEOF
     23955if ac_fn_cxx_try_link "$LINENO"; then :
     23956  flink_try=yes
     23957else
     23958  flink_try=no
     23959fi
     23960rm -f core conftest.err conftest.$ac_objext \
     23961    conftest$ac_exeext conftest.$ac_ext
     23962      ;;
     23963    c)
     23964      coin_need_flibs=no
     23965      flink_try=no
     23966       ac_ext=f
     23967ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     23968ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23969ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     23970
     23971  case $ac_cv_f77_mangling in
     23972  upper*) ac_val="DAXPY" ;;
     23973  lower*) ac_val="daxpy" ;;
     23974  *)      ac_val="unknown" ;;
     23975esac
     23976case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     23977
     23978cfuncdaxpy="$ac_val"
     23979
     23980  ac_ext=cpp
     23981ac_cpp='$CXXCPP $CPPFLAGS'
     23982ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     23983ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     23984ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     23985
     23986
     23987      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     23988      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     23989/* end confdefs.h.  */
     23990void $cfuncdaxpy();
     23991#ifdef F77_DUMMY_MAIN
     23992
     23993#  ifdef __cplusplus
     23994     extern "C"
     23995#  endif
     23996   int F77_DUMMY_MAIN() { return 1; }
     23997
     23998#endif
     23999int
     24000main ()
     24001{
     24002$cfuncdaxpy()
     24003  ;
     24004  return 0;
     24005}
     24006_ACEOF
     24007if ac_fn_cxx_try_link "$LINENO"; then :
     24008  flink_try=yes
     24009else
     24010  if test x"$FLIBS" != x ; then
     24011           flink_save_libs="$LIBS"
     24012           LIBS="$LIBS $FLIBS"
     24013           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24014/* end confdefs.h.  */
     24015void $cfuncdaxpy();
     24016#ifdef F77_DUMMY_MAIN
     24017
     24018#  ifdef __cplusplus
     24019     extern "C"
     24020#  endif
     24021   int F77_DUMMY_MAIN() { return 1; }
     24022
     24023#endif
     24024int
     24025main ()
     24026{
     24027$cfuncdaxpy()
     24028  ;
     24029  return 0;
     24030}
     24031_ACEOF
     24032if ac_fn_cxx_try_link "$LINENO"; then :
     24033  coin_need_flibs=yes
     24034              flink_try=yes
     24035
     24036fi
     24037rm -f core conftest.err conftest.$ac_objext \
     24038    conftest$ac_exeext conftest.$ac_ext
     24039           LIBS="$flink_save_libs"
     24040         fi
     24041
     24042
     24043fi
     24044rm -f core conftest.err conftest.$ac_objext \
     24045    conftest$ac_exeext conftest.$ac_ext
     24046      ;;
     24047    cc|cpp)
     24048      coin_need_flibs=no
     24049      flink_try=no
     24050       ac_ext=f
     24051ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24052ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24053ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24054
     24055  case $ac_cv_f77_mangling in
     24056  upper*) ac_val="DAXPY" ;;
     24057  lower*) ac_val="daxpy" ;;
     24058  *)      ac_val="unknown" ;;
     24059esac
     24060case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24061
     24062cfuncdaxpy="$ac_val"
     24063
     24064  ac_ext=cpp
     24065ac_cpp='$CXXCPP $CPPFLAGS'
     24066ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24067ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24068ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24069
     24070
     24071      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24072/* end confdefs.h.  */
     24073extern "C" {void $cfuncdaxpy();}
     24074#ifdef F77_DUMMY_MAIN
     24075
     24076#  ifdef __cplusplus
     24077     extern "C"
     24078#  endif
     24079   int F77_DUMMY_MAIN() { return 1; }
     24080
     24081#endif
     24082int
     24083main ()
     24084{
     24085$cfuncdaxpy()
     24086  ;
     24087  return 0;
     24088}
     24089_ACEOF
     24090if ac_fn_cxx_try_link "$LINENO"; then :
     24091  flink_try=yes
     24092else
     24093  if test x"$FLIBS" != x ; then
     24094           flink_save_libs="$LIBS"
     24095           LIBS="$LIBS $FLIBS"
     24096           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24097/* end confdefs.h.  */
     24098extern "C" {void $cfuncdaxpy();}
     24099#ifdef F77_DUMMY_MAIN
     24100
     24101#  ifdef __cplusplus
     24102     extern "C"
     24103#  endif
     24104   int F77_DUMMY_MAIN() { return 1; }
     24105
     24106#endif
     24107int
     24108main ()
     24109{
     24110$cfuncdaxpy()
     24111  ;
     24112  return 0;
     24113}
     24114_ACEOF
     24115if ac_fn_cxx_try_link "$LINENO"; then :
     24116  coin_need_flibs=yes
     24117              flink_try=yes
     24118
     24119fi
     24120rm -f core conftest.err conftest.$ac_objext \
     24121    conftest$ac_exeext conftest.$ac_ext
     24122           LIBS="$flink_save_libs"
     24123         fi
     24124
     24125
     24126fi
     24127rm -f core conftest.err conftest.$ac_objext \
     24128    conftest$ac_exeext conftest.$ac_ext
     24129      ;;
     24130  esac
     24131  if test $flink_try = yes ; then
     24132    if test $coin_need_flibs = no ; then
     24133       blas_lflags="-lcomplib.sgimath"
     24134     else
     24135       blas_lflags="-lcomplib.sgimath $FLIBS"
     24136     fi
     24137     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $blas_lflags" >&5
     24138$as_echo "yes: $blas_lflags" >&6; }
     24139  else
     24140    blas_lflags=
     24141     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     24142$as_echo "no" >&6; }
     24143  fi
     24144  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     24145
     24146  LIBS="$coin_save_LIBS"
     24147
     24148        ;;
     24149
     24150      *-*-solaris*)
     24151        # Ideally, we'd use -library=sunperf, but it's an imperfect world.
     24152        # Studio cc doesn't recognise -library, it wants -xlic_lib. Studio 12
     24153        # CC doesn't recognise -xlic_lib. Libtool doesn't like -xlic_lib
     24154        # anyway. Sun claims that CC and cc will understand -library in Studio
     24155        # 13. The main extra function of -xlic_lib and -library is to arrange
     24156        # for the Fortran run-time libraries to be linked for C++ and C. We
     24157        # can arrange that explicitly.
     24158        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BLAS in -lsunperf" >&5
     24159$as_echo_n "checking for BLAS in -lsunperf... " >&6; }
     24160
     24161  coin_save_LIBS="$LIBS"
     24162  LIBS="-lsunperf $LIBS"
     24163   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     24164  case $ac_ext in
     24165    f)
     24166      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24167/* end confdefs.h.  */
     24168
     24169#ifdef F77_DUMMY_MAIN
     24170
     24171#  ifdef __cplusplus
     24172     extern "C"
     24173#  endif
     24174   int F77_DUMMY_MAIN() { return 1; }
     24175
     24176#endif
     24177int
     24178main ()
     24179{
     24180      call daxpy
     24181  ;
     24182  return 0;
     24183}
     24184_ACEOF
     24185if ac_fn_cxx_try_link "$LINENO"; then :
     24186  flink_try=yes
     24187else
     24188  flink_try=no
     24189fi
     24190rm -f core conftest.err conftest.$ac_objext \
     24191    conftest$ac_exeext conftest.$ac_ext
     24192      ;;
     24193    c)
     24194      coin_need_flibs=no
     24195      flink_try=no
     24196       ac_ext=f
     24197ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24198ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24199ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24200
     24201  case $ac_cv_f77_mangling in
     24202  upper*) ac_val="DAXPY" ;;
     24203  lower*) ac_val="daxpy" ;;
     24204  *)      ac_val="unknown" ;;
     24205esac
     24206case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24207
     24208cfuncdaxpy="$ac_val"
     24209
     24210  ac_ext=cpp
     24211ac_cpp='$CXXCPP $CPPFLAGS'
     24212ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24213ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24214ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24215
     24216
     24217      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     24218      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24219/* end confdefs.h.  */
     24220void $cfuncdaxpy();
     24221#ifdef F77_DUMMY_MAIN
     24222
     24223#  ifdef __cplusplus
     24224     extern "C"
     24225#  endif
     24226   int F77_DUMMY_MAIN() { return 1; }
     24227
     24228#endif
     24229int
     24230main ()
     24231{
     24232$cfuncdaxpy()
     24233  ;
     24234  return 0;
     24235}
     24236_ACEOF
     24237if ac_fn_cxx_try_link "$LINENO"; then :
     24238  flink_try=yes
     24239else
     24240  if test x"$FLIBS" != x ; then
     24241           flink_save_libs="$LIBS"
     24242           LIBS="$LIBS $FLIBS"
     24243           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24244/* end confdefs.h.  */
     24245void $cfuncdaxpy();
     24246#ifdef F77_DUMMY_MAIN
     24247
     24248#  ifdef __cplusplus
     24249     extern "C"
     24250#  endif
     24251   int F77_DUMMY_MAIN() { return 1; }
     24252
     24253#endif
     24254int
     24255main ()
     24256{
     24257$cfuncdaxpy()
     24258  ;
     24259  return 0;
     24260}
     24261_ACEOF
     24262if ac_fn_cxx_try_link "$LINENO"; then :
     24263  coin_need_flibs=yes
     24264              flink_try=yes
     24265
     24266fi
     24267rm -f core conftest.err conftest.$ac_objext \
     24268    conftest$ac_exeext conftest.$ac_ext
     24269           LIBS="$flink_save_libs"
     24270         fi
     24271
     24272
     24273fi
     24274rm -f core conftest.err conftest.$ac_objext \
     24275    conftest$ac_exeext conftest.$ac_ext
     24276      ;;
     24277    cc|cpp)
     24278      coin_need_flibs=no
     24279      flink_try=no
     24280       ac_ext=f
     24281ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24282ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24283ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24284
     24285  case $ac_cv_f77_mangling in
     24286  upper*) ac_val="DAXPY" ;;
     24287  lower*) ac_val="daxpy" ;;
     24288  *)      ac_val="unknown" ;;
     24289esac
     24290case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24291
     24292cfuncdaxpy="$ac_val"
     24293
     24294  ac_ext=cpp
     24295ac_cpp='$CXXCPP $CPPFLAGS'
     24296ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24297ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24298ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24299
     24300
     24301      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24302/* end confdefs.h.  */
     24303extern "C" {void $cfuncdaxpy();}
     24304#ifdef F77_DUMMY_MAIN
     24305
     24306#  ifdef __cplusplus
     24307     extern "C"
     24308#  endif
     24309   int F77_DUMMY_MAIN() { return 1; }
     24310
     24311#endif
     24312int
     24313main ()
     24314{
     24315$cfuncdaxpy()
     24316  ;
     24317  return 0;
     24318}
     24319_ACEOF
     24320if ac_fn_cxx_try_link "$LINENO"; then :
     24321  flink_try=yes
     24322else
     24323  if test x"$FLIBS" != x ; then
     24324           flink_save_libs="$LIBS"
     24325           LIBS="$LIBS $FLIBS"
     24326           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24327/* end confdefs.h.  */
     24328extern "C" {void $cfuncdaxpy();}
     24329#ifdef F77_DUMMY_MAIN
     24330
     24331#  ifdef __cplusplus
     24332     extern "C"
     24333#  endif
     24334   int F77_DUMMY_MAIN() { return 1; }
     24335
     24336#endif
     24337int
     24338main ()
     24339{
     24340$cfuncdaxpy()
     24341  ;
     24342  return 0;
     24343}
     24344_ACEOF
     24345if ac_fn_cxx_try_link "$LINENO"; then :
     24346  coin_need_flibs=yes
     24347              flink_try=yes
     24348
     24349fi
     24350rm -f core conftest.err conftest.$ac_objext \
     24351    conftest$ac_exeext conftest.$ac_ext
     24352           LIBS="$flink_save_libs"
     24353         fi
     24354
     24355
     24356fi
     24357rm -f core conftest.err conftest.$ac_objext \
     24358    conftest$ac_exeext conftest.$ac_ext
     24359      ;;
     24360  esac
     24361  if test $flink_try = yes ; then
     24362    if test $coin_need_flibs = no ; then
     24363       blas_lflags="-lsunperf"
     24364     else
     24365       blas_lflags="-lsunperf $FLIBS"
     24366     fi
     24367     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $blas_lflags" >&5
     24368$as_echo "yes: $blas_lflags" >&6; }
     24369  else
     24370    blas_lflags=
     24371     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     24372$as_echo "no" >&6; }
     24373  fi
     24374  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     24375
     24376  LIBS="$coin_save_LIBS"
     24377
     24378        ;;
     24379
     24380      *-cygwin* | *-mingw*)
     24381        case "$CC" in
     24382          clang* ) ;;
     24383          cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
     24384            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BLAS in MKL (32bit)" >&5
     24385$as_echo_n "checking for BLAS in MKL (32bit)... " >&6; }
     24386
     24387  coin_save_LIBS="$LIBS"
     24388  LIBS="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib $LIBS"
     24389   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     24390  case $ac_ext in
     24391    f)
     24392      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24393/* end confdefs.h.  */
     24394
     24395#ifdef F77_DUMMY_MAIN
     24396
     24397#  ifdef __cplusplus
     24398     extern "C"
     24399#  endif
     24400   int F77_DUMMY_MAIN() { return 1; }
     24401
     24402#endif
     24403int
     24404main ()
     24405{
     24406      call daxpy
     24407  ;
     24408  return 0;
     24409}
     24410_ACEOF
     24411if ac_fn_cxx_try_link "$LINENO"; then :
     24412  flink_try=yes
     24413else
     24414  flink_try=no
     24415fi
     24416rm -f core conftest.err conftest.$ac_objext \
     24417    conftest$ac_exeext conftest.$ac_ext
     24418      ;;
     24419    c)
     24420      coin_need_flibs=no
     24421      flink_try=no
     24422       ac_ext=f
     24423ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24424ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24425ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24426
     24427  case $ac_cv_f77_mangling in
     24428  upper*) ac_val="DAXPY" ;;
     24429  lower*) ac_val="daxpy" ;;
     24430  *)      ac_val="unknown" ;;
     24431esac
     24432case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24433
     24434cfuncdaxpy="$ac_val"
     24435
     24436  ac_ext=cpp
     24437ac_cpp='$CXXCPP $CPPFLAGS'
     24438ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24439ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24440ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24441
     24442
     24443      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     24444      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24445/* end confdefs.h.  */
     24446void $cfuncdaxpy();
     24447#ifdef F77_DUMMY_MAIN
     24448
     24449#  ifdef __cplusplus
     24450     extern "C"
     24451#  endif
     24452   int F77_DUMMY_MAIN() { return 1; }
     24453
     24454#endif
     24455int
     24456main ()
     24457{
     24458$cfuncdaxpy()
     24459  ;
     24460  return 0;
     24461}
     24462_ACEOF
     24463if ac_fn_cxx_try_link "$LINENO"; then :
     24464  flink_try=yes
     24465else
     24466  if test x"$FLIBS" != x ; then
     24467           flink_save_libs="$LIBS"
     24468           LIBS="$LIBS $FLIBS"
     24469           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24470/* end confdefs.h.  */
     24471void $cfuncdaxpy();
     24472#ifdef F77_DUMMY_MAIN
     24473
     24474#  ifdef __cplusplus
     24475     extern "C"
     24476#  endif
     24477   int F77_DUMMY_MAIN() { return 1; }
     24478
     24479#endif
     24480int
     24481main ()
     24482{
     24483$cfuncdaxpy()
     24484  ;
     24485  return 0;
     24486}
     24487_ACEOF
     24488if ac_fn_cxx_try_link "$LINENO"; then :
     24489  coin_need_flibs=yes
     24490              flink_try=yes
     24491
     24492fi
     24493rm -f core conftest.err conftest.$ac_objext \
     24494    conftest$ac_exeext conftest.$ac_ext
     24495           LIBS="$flink_save_libs"
     24496         fi
     24497
     24498
     24499fi
     24500rm -f core conftest.err conftest.$ac_objext \
     24501    conftest$ac_exeext conftest.$ac_ext
     24502      ;;
     24503    cc|cpp)
     24504      coin_need_flibs=no
     24505      flink_try=no
     24506       ac_ext=f
     24507ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24508ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24509ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24510
     24511  case $ac_cv_f77_mangling in
     24512  upper*) ac_val="DAXPY" ;;
     24513  lower*) ac_val="daxpy" ;;
     24514  *)      ac_val="unknown" ;;
     24515esac
     24516case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24517
     24518cfuncdaxpy="$ac_val"
     24519
     24520  ac_ext=cpp
     24521ac_cpp='$CXXCPP $CPPFLAGS'
     24522ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24523ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24524ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24525
     24526
     24527      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24528/* end confdefs.h.  */
     24529extern "C" {void $cfuncdaxpy();}
     24530#ifdef F77_DUMMY_MAIN
     24531
     24532#  ifdef __cplusplus
     24533     extern "C"
     24534#  endif
     24535   int F77_DUMMY_MAIN() { return 1; }
     24536
     24537#endif
     24538int
     24539main ()
     24540{
     24541$cfuncdaxpy()
     24542  ;
     24543  return 0;
     24544}
     24545_ACEOF
     24546if ac_fn_cxx_try_link "$LINENO"; then :
     24547  flink_try=yes
     24548else
     24549  if test x"$FLIBS" != x ; then
     24550           flink_save_libs="$LIBS"
     24551           LIBS="$LIBS $FLIBS"
     24552           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24553/* end confdefs.h.  */
     24554extern "C" {void $cfuncdaxpy();}
     24555#ifdef F77_DUMMY_MAIN
     24556
     24557#  ifdef __cplusplus
     24558     extern "C"
     24559#  endif
     24560   int F77_DUMMY_MAIN() { return 1; }
     24561
     24562#endif
     24563int
     24564main ()
     24565{
     24566$cfuncdaxpy()
     24567  ;
     24568  return 0;
     24569}
     24570_ACEOF
     24571if ac_fn_cxx_try_link "$LINENO"; then :
     24572  coin_need_flibs=yes
     24573              flink_try=yes
     24574
     24575fi
     24576rm -f core conftest.err conftest.$ac_objext \
     24577    conftest$ac_exeext conftest.$ac_ext
     24578           LIBS="$flink_save_libs"
     24579         fi
     24580
     24581
     24582fi
     24583rm -f core conftest.err conftest.$ac_objext \
     24584    conftest$ac_exeext conftest.$ac_ext
     24585      ;;
     24586  esac
     24587  if test $flink_try = yes ; then
     24588    if test $coin_need_flibs = no ; then
     24589       blas_lflags="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib"
     24590     else
     24591       blas_lflags="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib $FLIBS"
     24592     fi
     24593     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $blas_lflags" >&5
     24594$as_echo "yes: $blas_lflags" >&6; }
     24595  else
     24596    blas_lflags=
     24597     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     24598$as_echo "no" >&6; }
     24599  fi
     24600  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     24601
     24602  LIBS="$coin_save_LIBS"
     24603
     24604            if test -z "$blas_lflags" ; then
     24605              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BLAS in MKL (64bit)" >&5
     24606$as_echo_n "checking for BLAS in MKL (64bit)... " >&6; }
     24607
     24608  coin_save_LIBS="$LIBS"
     24609  LIBS="mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib $LIBS"
     24610   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     24611  case $ac_ext in
     24612    f)
     24613      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24614/* end confdefs.h.  */
     24615
     24616#ifdef F77_DUMMY_MAIN
     24617
     24618#  ifdef __cplusplus
     24619     extern "C"
     24620#  endif
     24621   int F77_DUMMY_MAIN() { return 1; }
     24622
     24623#endif
     24624int
     24625main ()
     24626{
     24627      call daxpy
     24628  ;
     24629  return 0;
     24630}
     24631_ACEOF
     24632if ac_fn_cxx_try_link "$LINENO"; then :
     24633  flink_try=yes
     24634else
     24635  flink_try=no
     24636fi
     24637rm -f core conftest.err conftest.$ac_objext \
     24638    conftest$ac_exeext conftest.$ac_ext
     24639      ;;
     24640    c)
     24641      coin_need_flibs=no
     24642      flink_try=no
     24643       ac_ext=f
     24644ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24645ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24646ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24647
     24648  case $ac_cv_f77_mangling in
     24649  upper*) ac_val="DAXPY" ;;
     24650  lower*) ac_val="daxpy" ;;
     24651  *)      ac_val="unknown" ;;
     24652esac
     24653case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24654
     24655cfuncdaxpy="$ac_val"
     24656
     24657  ac_ext=cpp
     24658ac_cpp='$CXXCPP $CPPFLAGS'
     24659ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24660ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24661ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24662
     24663
     24664      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     24665      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24666/* end confdefs.h.  */
     24667void $cfuncdaxpy();
     24668#ifdef F77_DUMMY_MAIN
     24669
     24670#  ifdef __cplusplus
     24671     extern "C"
     24672#  endif
     24673   int F77_DUMMY_MAIN() { return 1; }
     24674
     24675#endif
     24676int
     24677main ()
     24678{
     24679$cfuncdaxpy()
     24680  ;
     24681  return 0;
     24682}
     24683_ACEOF
     24684if ac_fn_cxx_try_link "$LINENO"; then :
     24685  flink_try=yes
     24686else
     24687  if test x"$FLIBS" != x ; then
     24688           flink_save_libs="$LIBS"
     24689           LIBS="$LIBS $FLIBS"
     24690           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24691/* end confdefs.h.  */
     24692void $cfuncdaxpy();
     24693#ifdef F77_DUMMY_MAIN
     24694
     24695#  ifdef __cplusplus
     24696     extern "C"
     24697#  endif
     24698   int F77_DUMMY_MAIN() { return 1; }
     24699
     24700#endif
     24701int
     24702main ()
     24703{
     24704$cfuncdaxpy()
     24705  ;
     24706  return 0;
     24707}
     24708_ACEOF
     24709if ac_fn_cxx_try_link "$LINENO"; then :
     24710  coin_need_flibs=yes
     24711              flink_try=yes
     24712
     24713fi
     24714rm -f core conftest.err conftest.$ac_objext \
     24715    conftest$ac_exeext conftest.$ac_ext
     24716           LIBS="$flink_save_libs"
     24717         fi
     24718
     24719
     24720fi
     24721rm -f core conftest.err conftest.$ac_objext \
     24722    conftest$ac_exeext conftest.$ac_ext
     24723      ;;
     24724    cc|cpp)
     24725      coin_need_flibs=no
     24726      flink_try=no
     24727       ac_ext=f
     24728ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24729ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24730ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24731
     24732  case $ac_cv_f77_mangling in
     24733  upper*) ac_val="DAXPY" ;;
     24734  lower*) ac_val="daxpy" ;;
     24735  *)      ac_val="unknown" ;;
     24736esac
     24737case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24738
     24739cfuncdaxpy="$ac_val"
     24740
     24741  ac_ext=cpp
     24742ac_cpp='$CXXCPP $CPPFLAGS'
     24743ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24744ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24745ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24746
     24747
     24748      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24749/* end confdefs.h.  */
     24750extern "C" {void $cfuncdaxpy();}
     24751#ifdef F77_DUMMY_MAIN
     24752
     24753#  ifdef __cplusplus
     24754     extern "C"
     24755#  endif
     24756   int F77_DUMMY_MAIN() { return 1; }
     24757
     24758#endif
     24759int
     24760main ()
     24761{
     24762$cfuncdaxpy()
     24763  ;
     24764  return 0;
     24765}
     24766_ACEOF
     24767if ac_fn_cxx_try_link "$LINENO"; then :
     24768  flink_try=yes
     24769else
     24770  if test x"$FLIBS" != x ; then
     24771           flink_save_libs="$LIBS"
     24772           LIBS="$LIBS $FLIBS"
     24773           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24774/* end confdefs.h.  */
     24775extern "C" {void $cfuncdaxpy();}
     24776#ifdef F77_DUMMY_MAIN
     24777
     24778#  ifdef __cplusplus
     24779     extern "C"
     24780#  endif
     24781   int F77_DUMMY_MAIN() { return 1; }
     24782
     24783#endif
     24784int
     24785main ()
     24786{
     24787$cfuncdaxpy()
     24788  ;
     24789  return 0;
     24790}
     24791_ACEOF
     24792if ac_fn_cxx_try_link "$LINENO"; then :
     24793  coin_need_flibs=yes
     24794              flink_try=yes
     24795
     24796fi
     24797rm -f core conftest.err conftest.$ac_objext \
     24798    conftest$ac_exeext conftest.$ac_ext
     24799           LIBS="$flink_save_libs"
     24800         fi
     24801
     24802
     24803fi
     24804rm -f core conftest.err conftest.$ac_objext \
     24805    conftest$ac_exeext conftest.$ac_ext
     24806      ;;
     24807  esac
     24808  if test $flink_try = yes ; then
     24809    if test $coin_need_flibs = no ; then
     24810       blas_lflags="mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib"
     24811     else
     24812       blas_lflags="mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib $FLIBS"
     24813     fi
     24814     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $blas_lflags" >&5
     24815$as_echo "yes: $blas_lflags" >&6; }
     24816  else
     24817    blas_lflags=
     24818     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     24819$as_echo "no" >&6; }
     24820  fi
     24821  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     24822
     24823  LIBS="$coin_save_LIBS"
     24824
     24825            fi
     24826            ;;
     24827        esac
     24828        ;;
     24829
     24830       *-darwin*)
     24831        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BLAS in Veclib" >&5
     24832$as_echo_n "checking for BLAS in Veclib... " >&6; }
     24833
     24834  coin_save_LIBS="$LIBS"
     24835  LIBS="-framework Accelerate $LIBS"
     24836   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     24837  case $ac_ext in
     24838    f)
     24839      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24840/* end confdefs.h.  */
     24841
     24842#ifdef F77_DUMMY_MAIN
     24843
     24844#  ifdef __cplusplus
     24845     extern "C"
     24846#  endif
     24847   int F77_DUMMY_MAIN() { return 1; }
     24848
     24849#endif
     24850int
     24851main ()
     24852{
     24853      call daxpy
     24854  ;
     24855  return 0;
     24856}
     24857_ACEOF
     24858if ac_fn_cxx_try_link "$LINENO"; then :
     24859  flink_try=yes
     24860else
     24861  flink_try=no
     24862fi
     24863rm -f core conftest.err conftest.$ac_objext \
     24864    conftest$ac_exeext conftest.$ac_ext
     24865      ;;
     24866    c)
     24867      coin_need_flibs=no
     24868      flink_try=no
     24869       ac_ext=f
     24870ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24871ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24872ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24873
     24874  case $ac_cv_f77_mangling in
     24875  upper*) ac_val="DAXPY" ;;
     24876  lower*) ac_val="daxpy" ;;
     24877  *)      ac_val="unknown" ;;
     24878esac
     24879case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24880
     24881cfuncdaxpy="$ac_val"
     24882
     24883  ac_ext=cpp
     24884ac_cpp='$CXXCPP $CPPFLAGS'
     24885ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24886ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24887ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24888
     24889
     24890      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     24891      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24892/* end confdefs.h.  */
     24893void $cfuncdaxpy();
     24894#ifdef F77_DUMMY_MAIN
     24895
     24896#  ifdef __cplusplus
     24897     extern "C"
     24898#  endif
     24899   int F77_DUMMY_MAIN() { return 1; }
     24900
     24901#endif
     24902int
     24903main ()
     24904{
     24905$cfuncdaxpy()
     24906  ;
     24907  return 0;
     24908}
     24909_ACEOF
     24910if ac_fn_cxx_try_link "$LINENO"; then :
     24911  flink_try=yes
     24912else
     24913  if test x"$FLIBS" != x ; then
     24914           flink_save_libs="$LIBS"
     24915           LIBS="$LIBS $FLIBS"
     24916           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24917/* end confdefs.h.  */
     24918void $cfuncdaxpy();
     24919#ifdef F77_DUMMY_MAIN
     24920
     24921#  ifdef __cplusplus
     24922     extern "C"
     24923#  endif
     24924   int F77_DUMMY_MAIN() { return 1; }
     24925
     24926#endif
     24927int
     24928main ()
     24929{
     24930$cfuncdaxpy()
     24931  ;
     24932  return 0;
     24933}
     24934_ACEOF
     24935if ac_fn_cxx_try_link "$LINENO"; then :
     24936  coin_need_flibs=yes
     24937              flink_try=yes
     24938
     24939fi
     24940rm -f core conftest.err conftest.$ac_objext \
     24941    conftest$ac_exeext conftest.$ac_ext
     24942           LIBS="$flink_save_libs"
     24943         fi
     24944
     24945
     24946fi
     24947rm -f core conftest.err conftest.$ac_objext \
     24948    conftest$ac_exeext conftest.$ac_ext
     24949      ;;
     24950    cc|cpp)
     24951      coin_need_flibs=no
     24952      flink_try=no
     24953       ac_ext=f
     24954ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     24955ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24956ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     24957
     24958  case $ac_cv_f77_mangling in
     24959  upper*) ac_val="DAXPY" ;;
     24960  lower*) ac_val="daxpy" ;;
     24961  *)      ac_val="unknown" ;;
     24962esac
     24963case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     24964
     24965cfuncdaxpy="$ac_val"
     24966
     24967  ac_ext=cpp
     24968ac_cpp='$CXXCPP $CPPFLAGS'
     24969ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     24970ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     24971ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     24972
     24973
     24974      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     24975/* end confdefs.h.  */
     24976extern "C" {void $cfuncdaxpy();}
     24977#ifdef F77_DUMMY_MAIN
     24978
     24979#  ifdef __cplusplus
     24980     extern "C"
     24981#  endif
     24982   int F77_DUMMY_MAIN() { return 1; }
     24983
     24984#endif
     24985int
     24986main ()
     24987{
     24988$cfuncdaxpy()
     24989  ;
     24990  return 0;
     24991}
     24992_ACEOF
     24993if ac_fn_cxx_try_link "$LINENO"; then :
     24994  flink_try=yes
     24995else
     24996  if test x"$FLIBS" != x ; then
     24997           flink_save_libs="$LIBS"
     24998           LIBS="$LIBS $FLIBS"
     24999           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     25000/* end confdefs.h.  */
     25001extern "C" {void $cfuncdaxpy();}
     25002#ifdef F77_DUMMY_MAIN
     25003
     25004#  ifdef __cplusplus
     25005     extern "C"
     25006#  endif
     25007   int F77_DUMMY_MAIN() { return 1; }
     25008
     25009#endif
     25010int
     25011main ()
     25012{
     25013$cfuncdaxpy()
     25014  ;
     25015  return 0;
     25016}
     25017_ACEOF
     25018if ac_fn_cxx_try_link "$LINENO"; then :
     25019  coin_need_flibs=yes
     25020              flink_try=yes
     25021
     25022fi
     25023rm -f core conftest.err conftest.$ac_objext \
     25024    conftest$ac_exeext conftest.$ac_ext
     25025           LIBS="$flink_save_libs"
     25026         fi
     25027
     25028
     25029fi
     25030rm -f core conftest.err conftest.$ac_objext \
     25031    conftest$ac_exeext conftest.$ac_ext
     25032      ;;
     25033  esac
     25034  if test $flink_try = yes ; then
     25035    if test $coin_need_flibs = no ; then
     25036       blas_lflags="-framework Accelerate"
     25037     else
     25038       blas_lflags="-framework Accelerate $FLIBS"
     25039     fi
     25040     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $blas_lflags" >&5
     25041$as_echo "yes: $blas_lflags" >&6; }
     25042  else
     25043    blas_lflags=
     25044     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     25045$as_echo "no" >&6; }
     25046  fi
     25047  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     25048
     25049  LIBS="$coin_save_LIBS"
     25050
     25051        ;;
     25052    esac
     25053    if test -z "$blas_lflags" ; then
     25054      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BLAS in -lblas" >&5
     25055$as_echo_n "checking for BLAS in -lblas... " >&6; }
     25056
     25057  coin_save_LIBS="$LIBS"
     25058  LIBS="-lblas $LIBS"
     25059   # AC_MSG_NOTICE([In COIN_TRY_FLINK])
     25060  case $ac_ext in
     25061    f)
     25062      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     25063/* end confdefs.h.  */
     25064
     25065#ifdef F77_DUMMY_MAIN
     25066
     25067#  ifdef __cplusplus
     25068     extern "C"
     25069#  endif
     25070   int F77_DUMMY_MAIN() { return 1; }
     25071
     25072#endif
     25073int
     25074main ()
     25075{
     25076      call daxpy
     25077  ;
     25078  return 0;
     25079}
     25080_ACEOF
     25081if ac_fn_cxx_try_link "$LINENO"; then :
     25082  flink_try=yes
     25083else
     25084  flink_try=no
     25085fi
     25086rm -f core conftest.err conftest.$ac_objext \
     25087    conftest$ac_exeext conftest.$ac_ext
     25088      ;;
     25089    c)
     25090      coin_need_flibs=no
     25091      flink_try=no
     25092       ac_ext=f
     25093ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25094ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25095ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25096
     25097  case $ac_cv_f77_mangling in
     25098  upper*) ac_val="DAXPY" ;;
     25099  lower*) ac_val="daxpy" ;;
     25100  *)      ac_val="unknown" ;;
     25101esac
     25102case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     25103
     25104cfuncdaxpy="$ac_val"
     25105
     25106  ac_ext=cpp
     25107ac_cpp='$CXXCPP $CPPFLAGS'
     25108ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     25109ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25110ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     25111
     25112
     25113      # AC_MSG_NOTICE([COIN_TRY_FLINK: daxpy -> $cfuncdaxpy])
     25114      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     25115/* end confdefs.h.  */
     25116void $cfuncdaxpy();
     25117#ifdef F77_DUMMY_MAIN
     25118
     25119#  ifdef __cplusplus
     25120     extern "C"
     25121#  endif
     25122   int F77_DUMMY_MAIN() { return 1; }
     25123
     25124#endif
     25125int
     25126main ()
     25127{
     25128$cfuncdaxpy()
     25129  ;
     25130  return 0;
     25131}
     25132_ACEOF
     25133if ac_fn_cxx_try_link "$LINENO"; then :
     25134  flink_try=yes
     25135else
     25136  if test x"$FLIBS" != x ; then
     25137           flink_save_libs="$LIBS"
     25138           LIBS="$LIBS $FLIBS"
     25139           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     25140/* end confdefs.h.  */
     25141void $cfuncdaxpy();
     25142#ifdef F77_DUMMY_MAIN
     25143
     25144#  ifdef __cplusplus
     25145     extern "C"
     25146#  endif
     25147   int F77_DUMMY_MAIN() { return 1; }
     25148
     25149#endif
     25150int
     25151main ()
     25152{
     25153$cfuncdaxpy()
     25154  ;
     25155  return 0;
     25156}
     25157_ACEOF
     25158if ac_fn_cxx_try_link "$LINENO"; then :
     25159  coin_need_flibs=yes
     25160              flink_try=yes
     25161
     25162fi
     25163rm -f core conftest.err conftest.$ac_objext \
     25164    conftest$ac_exeext conftest.$ac_ext
     25165           LIBS="$flink_save_libs"
     25166         fi
     25167
     25168
     25169fi
     25170rm -f core conftest.err conftest.$ac_objext \
     25171    conftest$ac_exeext conftest.$ac_ext
     25172      ;;
     25173    cc|cpp)
     25174      coin_need_flibs=no
     25175      flink_try=no
     25176       ac_ext=f
     25177ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     25178ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25179ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     25180
     25181  case $ac_cv_f77_mangling in
     25182  upper*) ac_val="DAXPY" ;;
     25183  lower*) ac_val="daxpy" ;;
     25184  *)      ac_val="unknown" ;;
     25185esac
     25186case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
     25187
     25188cfuncdaxpy="$ac_val"
     25189
     25190  ac_ext=cpp
     25191ac_cpp='$CXXCPP $CPPFLAGS'
     25192ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     25193ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     25194ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     25195
     25196
     25197      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     25198/* end confdefs.h.  */
     25199extern "C" {void $cfuncdaxpy();}
     25200#ifdef F77_DUMMY_MAIN
     25201
     25202#  ifdef __cplusplus
     25203     extern "C"
     25204#  endif
     25205   int F77_DUMMY_MAIN() { return 1; }
     25206
     25207#endif
     25208int
     25209main ()
     25210{
     25211$cfuncdaxpy()
     25212  ;
     25213  return 0;
     25214}
     25215_ACEOF
     25216if ac_fn_cxx_try_link "$LINENO"; then :
     25217  flink_try=yes
     25218else
     25219  if test x"$FLIBS" != x ; then
     25220           flink_save_libs="$LIBS"
     25221           LIBS="$LIBS $FLIBS"
     25222           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     25223/* end confdefs.h.  */
     25224extern "C" {void $cfuncdaxpy();}
     25225#ifdef F77_DUMMY_MAIN
     25226
     25227#  ifdef __cplusplus
     25228     extern "C"
     25229#  endif
     25230   int F77_DUMMY_MAIN() { return 1; }
     25231
     25232#endif
     25233int
     25234main ()
     25235{
     25236$cfuncdaxpy()
     25237  ;
     25238  return 0;
     25239}
     25240_ACEOF
     25241if ac_fn_cxx_try_link "$LINENO"; then :
     25242  coin_need_flibs=yes
     25243              flink_try=yes
     25244
     25245fi
     25246rm -f core conftest.err conftest.$ac_objext \
     25247    conftest$ac_exeext conftest.$ac_ext
     25248           LIBS="$flink_save_libs"
     25249         fi
     25250
     25251
     25252fi
     25253rm -f core conftest.err conftest.$ac_objext \
     25254    conftest$ac_exeext conftest.$ac_ext
     25255      ;;
     25256  esac
     25257  if test $flink_try = yes ; then
     25258    if test $coin_need_flibs = no ; then
     25259       blas_lflags="-lblas"
     25260     else
     25261       blas_lflags="-lblas $FLIBS"
     25262     fi
     25263     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes: $blas_lflags" >&5
     25264$as_echo "yes: $blas_lflags" >&6; }
     25265  else
     25266    blas_lflags=
     25267     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     25268$as_echo "no" >&6; }
     25269  fi
     25270  # AC_MSG_NOTICE([Done COIN_TRY_FLINK])
     25271
     25272  LIBS="$coin_save_LIBS"
     25273
     25274    fi
     25275    if test -n "$blas_lflags" ; then
     25276      coin_has_blas=yes
     25277    fi
     25278  fi
     25279
     25280# Done. Time to set some variables. Create an automake conditional
     25281# COIN_HAS_BLAS.
     25282
     25283   if test $coin_has_blas = yes; then
     25284  COIN_HAS_BLAS_TRUE=
     25285  COIN_HAS_BLAS_FALSE='#'
     25286else
     25287  COIN_HAS_BLAS_TRUE='#'
     25288  COIN_HAS_BLAS_FALSE=
     25289fi
     25290
     25291
     25292# If we've located the package, define preprocessor symbol COIN_HAS_BLAS
     25293# and augment the necessary variables for the client packages.
     25294
     25295  if test $coin_has_blas = yes ; then
     25296
     25297$as_echo "#define COIN_HAS_BLAS 1" >>confdefs.h
     25298
     25299    CLPLIB_PCFILES="$blas_pcfiles $CLPLIB_PCFILES"
     25300       CLPLIB_LFLAGS="$blas_lflags $CLPLIB_LFLAGS"
     25301       CLPLIB_CFLAGS="$blas_cflags $CLPLIB_CFLAGS"
     25302
     25303  else
     25304    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $coin_has_blas" >&5
     25305$as_echo "$coin_has_blas" >&6; }
     25306  fi
     25307
     25308
    2334425309  use_wsmp=
    2334525310
     
    2357525540else
    2357625541  # to please configure
    23577   # AM_CONDITIONAL(COIN_HAS_BLAS, [test 0 = 1])
     25542   if test 0 = 1; then
     25543  COIN_HAS_BLAS_TRUE=
     25544  COIN_HAS_BLAS_FALSE='#'
     25545else
     25546  COIN_HAS_BLAS_TRUE='#'
     25547  COIN_HAS_BLAS_FALSE=
     25548fi
     25549
    2357825550  :
    2357925551fi
     
    2465126623if test -z "${COIN_HAS_WSMP_TRUE}" && test -z "${COIN_HAS_WSMP_FALSE}"; then
    2465226624  as_fn_error $? "conditional \"COIN_HAS_WSMP\" was never defined.
     26625Usually this means the macro was only invoked conditionally." "$LINENO" 5
     26626fi
     26627if test -z "${COIN_HAS_BLAS_TRUE}" && test -z "${COIN_HAS_BLAS_FALSE}"; then
     26628  as_fn_error $? "conditional \"COIN_HAS_BLAS\" was never defined.
     26629Usually this means the macro was only invoked conditionally." "$LINENO" 5
     26630fi
     26631if test -z "${COIN_HAS_BLAS_TRUE}" && test -z "${COIN_HAS_BLAS_FALSE}"; then
     26632  as_fn_error $? "conditional \"COIN_HAS_BLAS\" was never defined.
    2465326633Usually this means the macro was only invoked conditionally." "$LINENO" 5
    2465426634fi
  • branches/autotools-update/Clp/configure.ac

    r2339 r2341  
    9696#############################################################################
    9797
    98 # AMD from UFL
    99 # [amd.h] [amd_defaults]
    100 
    101 AC_COIN_CHK_LIB(AMD,[ClpLib],[-lamd],[-I/usr/include/suitesparse])
    102 
    103 # CHOLMOD from UFL (requires AMD).
    104 # [cholmod.h] [cholmod_start]
    105 
    106 AC_COIN_CHK_LIB(CHOLMOD,[ClpLib],[-lcholmod],[-I/usr/include/suitesparse])
     98# AMD and CHOLMOD from UFL. Glpk is an alternative source for amd. CHOLMOD
     99# doc'n claims it requires METIS, but apparently that's not necessary for the
     100# version distributed with Fedora.
     101
     102# amd.h
     103AC_COIN_CHK_LIB(AMD,[ClpLib],[-lamd],[-I/usr/include/suitesparse],[],
     104                [amd_defaults])
     105
     106# CHOLMOD from UFL
     107# Requires AMD, but apparently not for a link check with dynamic libraries.
     108# cholmod.h
     109
     110AC_COIN_CHK_LIB(CHOLMOD,[ClpLib],[-lcholmod],[-I/usr/include/suitesparse],[],
     111                [cholmod_start])
    107112
    108113# Glpk also brings AMD
     
    127132
    128133if test "$use_wsmp" = yes ; then
    129   # AC_COIN_CHK_PKG_BLAS(ClpLib)
     134  AC_COIN_CHK_BLAS(ClpLib)
    130135  use_wsmp=
    131136  AC_COIN_CHK_PKG_FLINK([use_wsmp],wssmp,[$wsmp_libs])
     
    140145else
    141146  # to please configure
    142   # AM_CONDITIONAL(COIN_HAS_BLAS, [test 0 = 1])
     147  AM_CONDITIONAL(COIN_HAS_BLAS, [test 0 = 1])
    143148  :
    144149fi
  • branches/autotools-update/Clp/src/config.h.in

    r2334 r2341  
    2424/* Define to 1 if ASL is available. */
    2525#undef COIN_HAS_ASL
     26
     27/* Define to 1 if BLAS is available. */
     28#undef COIN_HAS_BLAS
    2629
    2730/* Define to 1 if the CHOLMOD package is available */
Note: See TracChangeset for help on using the changeset viewer.