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 |