| 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 | | |
| 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 |
