Changeset 1580


Ignore:
Timestamp:
Jul 25, 2010 3:57:53 PM (9 years ago)
Author:
stefan
Message:

COIN_HAS_MODULE_FALLBACK is now always called by COIN_HAS_MODULE and checks dependencies, thus simplify configure.ac; rerun autotools

Location:
trunk/Clp
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/configure

    r1577 r1580  
    2079220792    export PKG_CONFIG_PATH
    2079320793  else
    20794     #if 4th argument is given, try fallback - whereby we take the first word from coinutils = trunk as basename for the .pc file
    20795     echo "$as_me:$LINENO: result: skipped check via pkg-config" >&5
    20796 echo "${ECHO_T}skipped check via pkg-config" >&6
     20794    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     20795echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     20796
     20797echo "$as_me:$LINENO: checking for COIN-OR module CoinUtils (fallback)" >&5
     20798echo $ECHO_N "checking for COIN-OR module CoinUtils (fallback)... $ECHO_C" >&6
     20799
     20800coin_has_coinutils=notGiven
     20801COINUTILS_LIBS=
     20802COINUTILS_CFLAGS=
     20803COINUTILS_DATA=
     20804
     20805
     20806# initial list of dependencies is "coinutils = trunk", but we need to filter out version number specifications (= x, <= x, >= x)
     20807projtoprocess="coinutils "
     20808projprocessed=""
     20809
     20810while test $coin_has_coinutils = notGiven ; do
     20811  # setup list of projects that need to be processed in the next round
     20812  nextprojtoprocess=""
     20813
     20814  for proj in $projtoprocess ; do
     20815    # if $proj has been processed already, skip this round
     20816    if test "x$projprocessed" != x ; then
     20817      for projdone in $projprocessed ; do
     20818        if test $projdone = $proj ; then
     20819          continue 2
     20820        fi
     20821      done
     20822    fi
     20823
     20824    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     20825    pcfile=""
     20826    save_IFS="$IFS"
     20827    IFS=":"
     20828    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     20829      # 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
     20830      if test -r "$dir/$proj-uninstalled.pc" ; then
     20831        pcfile="$dir/$proj-uninstalled.pc"
     20832        pcfiledir="$dir"
     20833        break
     20834      fi
     20835    done
     20836    IFS="$save_IFS"
     20837
     20838    if test "x$pcfile" != x ; then
     20839      # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     20840      projcflags=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' "$pcfile"`
     20841      COINUTILS_CFLAGS="$projcflags $COINUTILS_CFLAGS"
     20842
     20843      # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     20844      # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     20845      projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     20846      if test "x$projlibs" != x ; then
     20847        if test -d "${pcfiledir}/src" ; then
     20848          projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     20849        else
     20850          projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     20851        fi
     20852      else
     20853        projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     20854      fi
     20855      COINUTILS_LIBS="$projlibs $COINUTILS_LIBS"
     20856
     20857      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
     20858      if test "x$projprocessed" = x ; then
     20859        COINUTILS_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
     20860      fi
     20861
     20862      # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
     20863      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
     20864      nextprojtoprocess="$nextprojtoprocess $projrequires"
     20865
     20866      # remember that we have processed $proj
     20867      projprocessed="$projprocessed $proj"
     20868
     20869    else
     20870      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     20871echo "${ECHO_T}no, dependency $proj not available" >&6
     20872      break 2
     20873    fi
     20874
     20875  done
     20876
     20877  projtoprocess="$nextprojtoprocess"
     20878
     20879  if test "x$projtoprocess" = x ; then
     20880    coin_has_coinutils=yes
     20881    echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
     20882echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     20883
     20884    REQUIREDPACKAGES="coinutils = trunk $REQUIREDPACKAGES"
     20885
     20886cat >>confdefs.h <<\_ACEOF
     20887#define COIN_HAS_COINUTILS 1
     20888_ACEOF
     20889
     20890
     20891    if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     20892    if test -n "$COINUTILS_CFLAGS" ; then
     20893      { echo "$as_me:$LINENO: CoinUtils CFLAGS are $COINUTILS_CFLAGS" >&5
     20894echo "$as_me: CoinUtils CFLAGS are $COINUTILS_CFLAGS" >&6;}
     20895    fi
     20896    if test -n "$COINUTILS_LIBS" ; then
     20897      { echo "$as_me:$LINENO: CoinUtils LIBS   are $COINUTILS_LIBS" >&5
     20898echo "$as_me: CoinUtils LIBS   are $COINUTILS_LIBS" >&6;}
     20899    fi
     20900    if test -n "$COINUTILS_DATA" ; then
     20901      { echo "$as_me:$LINENO: CoinUtils DATA   is  $COINUTILS_DATA" >&5
     20902echo "$as_me: CoinUtils DATA   is  $COINUTILS_DATA" >&6;}
     20903    fi
     20904    fi
     20905  fi
     20906done
     20907
     20908
     20909
     20910if test $coin_has_coinutils != notGiven &&
     20911                test $coin_has_coinutils != skipping; then
     20912  COIN_HAS_COINUTILS_TRUE=
     20913  COIN_HAS_COINUTILS_FALSE='#'
     20914else
     20915  COIN_HAS_COINUTILS_TRUE='#'
     20916  COIN_HAS_COINUTILS_FALSE=
     20917fi
     20918
     20919
    2079720920
    2079820921  fi
     
    2083920962
    2084020963
    20841 
    20842 if test $coin_has_coinutils != yes ; then
    20843   #if we have to use the fallback routines, then obviously it will not find CoinUtils dependencies
    20844   #thus, we check whether ThirdParty/Blas and ThirdParty/Lapack have been setup and
    20845   #assume that if present then they are dependencies of CoinUtils
    20846 
    20847 if test x$coin_has_blas != "xyes" ; then
    20848 
    20849 echo "$as_me:$LINENO: checking for COIN-OR module Blas (fallback)" >&5
    20850 echo $ECHO_N "checking for COIN-OR module Blas (fallback)... $ECHO_C" >&6
    20851 
    20852 coin_has_blas=notGiven
    20853 
    20854 # check if user wants to skip module in any case
    20855 if test x"$COIN_SKIP_PROJECTS" != x; then
    20856   for dir in $COIN_SKIP_PROJECTS; do
    20857     if test $dir = "Blas"; then
    20858       coin_has_blas=skipping
    20859     fi
    20860   done
    20861 fi
    20862 
    20863 BLAS_LIBS=
    20864 BLAS_CFLAGS=
    20865 BLAS_DATA=
    20866 
    20867 
    20868 if test $coin_has_blas != "skipping" ; then
    20869   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    20870   if test -r ../ThirdParty/Blas/coinblas-uninstalled.pc ; then
    20871     # read CFLAGS and LIBS from coinblas-uninstalled.pc file
    20872     # add CYGPATH_W cludge into include flags
    20873     # replace -L${libdir} by absolute path to build directory in linker flags
    20874     # we assume that the build directory is ../ThirdParty/Blas/src if this directory exists, otherwise we assume that it is ../ThirdParty/Blas
    20875     BLAS_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../ThirdParty/Blas/coinblas-uninstalled.pc`
    20876     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../ThirdParty/Blas/coinblas-uninstalled.pc`
    20877     if test "x$projectlibs" != x ; then
    20878       if test -d ../ThirdParty/Blas/src ; then
    20879         BLAS_LIBS="-L`cd ../ThirdParty/Blas/src; pwd` $projectlibs"
    20880       else
    20881         BLAS_LIBS="-L`cd ../ThirdParty/Blas; pwd` $projectlibs"
    20882       fi
    20883     else
    20884       BLAS_LIBS=`sed -n -e 's/Libs://p' ../ThirdParty/Blas/coinblas-uninstalled.pc`
    20885     fi
    20886     BLAS_DATA=`sed -n -e 's/datadir=//gp' ../ThirdParty/Blas/coinblas-uninstalled.pc`
    20887 
    20888 
    20889 
    20890 
    20891 
    20892     coin_has_blas=yes
    20893     echo "$as_me:$LINENO: result: ../ThirdParty/Blas" >&5
    20894 echo "${ECHO_T}../ThirdParty/Blas" >&6
    20895   else
    20896     echo "$as_me:$LINENO: result: $coin_has_blas" >&5
    20897 echo "${ECHO_T}$coin_has_blas" >&6
    20898   fi
    20899 else
    20900   echo "$as_me:$LINENO: result: skipping" >&5
    20901 echo "${ECHO_T}skipping" >&6
    20902 fi
    20903 
    20904 #if user did not disable setting of makefile conditional, do it
    20905 
    20906 fi
    20907 
    20908 
    20909 if test x$coin_has_lapack != "xyes" ; then
    20910 
    20911 echo "$as_me:$LINENO: checking for COIN-OR module Lapack (fallback)" >&5
    20912 echo $ECHO_N "checking for COIN-OR module Lapack (fallback)... $ECHO_C" >&6
    20913 
    20914 coin_has_lapack=notGiven
    20915 
    20916 # check if user wants to skip module in any case
    20917 if test x"$COIN_SKIP_PROJECTS" != x; then
    20918   for dir in $COIN_SKIP_PROJECTS; do
    20919     if test $dir = "Lapack"; then
    20920       coin_has_lapack=skipping
    20921     fi
    20922   done
    20923 fi
    20924 
    20925 LAPACK_LIBS=
    20926 LAPACK_CFLAGS=
    20927 LAPACK_DATA=
    20928 
    20929 
    20930 if test $coin_has_lapack != "skipping" ; then
    20931   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    20932   if test -r ../ThirdParty/Lapack/coinlapack-uninstalled.pc ; then
    20933     # read CFLAGS and LIBS from coinlapack-uninstalled.pc file
    20934     # add CYGPATH_W cludge into include flags
    20935     # replace -L${libdir} by absolute path to build directory in linker flags
    20936     # we assume that the build directory is ../ThirdParty/Lapack/src if this directory exists, otherwise we assume that it is ../ThirdParty/Lapack
    20937     LAPACK_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../ThirdParty/Lapack/coinlapack-uninstalled.pc`
    20938     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../ThirdParty/Lapack/coinlapack-uninstalled.pc`
    20939     if test "x$projectlibs" != x ; then
    20940       if test -d ../ThirdParty/Lapack/src ; then
    20941         LAPACK_LIBS="-L`cd ../ThirdParty/Lapack/src; pwd` $projectlibs"
    20942       else
    20943         LAPACK_LIBS="-L`cd ../ThirdParty/Lapack; pwd` $projectlibs"
    20944       fi
    20945     else
    20946       LAPACK_LIBS=`sed -n -e 's/Libs://p' ../ThirdParty/Lapack/coinlapack-uninstalled.pc`
    20947     fi
    20948     LAPACK_DATA=`sed -n -e 's/datadir=//gp' ../ThirdParty/Lapack/coinlapack-uninstalled.pc`
    20949 
    20950 
    20951 
    20952 
    20953 
    20954     coin_has_lapack=yes
    20955     echo "$as_me:$LINENO: result: ../ThirdParty/Lapack" >&5
    20956 echo "${ECHO_T}../ThirdParty/Lapack" >&6
    20957   else
    20958     echo "$as_me:$LINENO: result: $coin_has_lapack" >&5
    20959 echo "${ECHO_T}$coin_has_lapack" >&6
    20960   fi
    20961 else
    20962   echo "$as_me:$LINENO: result: skipping" >&5
    20963 echo "${ECHO_T}skipping" >&6
    20964 fi
    20965 
    20966 #if user did not disable setting of makefile conditional, do it
    20967 
    20968 fi
    20969 
    20970 fi
    20971 
    20972 if test x$coin_has_coinutils != "xyes" ; then
    20973 
    20974 echo "$as_me:$LINENO: checking for COIN-OR module CoinUtils (fallback)" >&5
    20975 echo $ECHO_N "checking for COIN-OR module CoinUtils (fallback)... $ECHO_C" >&6
    20976 
    20977 coin_has_coinutils=notGiven
    20978 
    20979 # check if user wants to skip module in any case
    20980 if test x"$COIN_SKIP_PROJECTS" != x; then
    20981   for dir in $COIN_SKIP_PROJECTS; do
    20982     if test $dir = "CoinUtils"; then
    20983       coin_has_coinutils=skipping
    20984     fi
    20985   done
    20986 fi
    20987 
    20988 COINUTILS_LIBS=
    20989 COINUTILS_CFLAGS=
    20990 COINUTILS_DATA=
    20991 
    20992 
    20993 if test $coin_has_coinutils != "skipping" ; then
    20994   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    20995   if test -r ../CoinUtils/coinutils-uninstalled.pc ; then
    20996     # read CFLAGS and LIBS from coinutils-uninstalled.pc file
    20997     # add CYGPATH_W cludge into include flags
    20998     # replace -L${libdir} by absolute path to build directory in linker flags
    20999     # we assume that the build directory is ../CoinUtils/src if this directory exists, otherwise we assume that it is ../CoinUtils
    21000     COINUTILS_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../CoinUtils/coinutils-uninstalled.pc`
    21001     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../CoinUtils/coinutils-uninstalled.pc`
    21002     if test "x$projectlibs" != x ; then
    21003       if test -d ../CoinUtils/src ; then
    21004         COINUTILS_LIBS="-L`cd ../CoinUtils/src; pwd` $projectlibs"
    21005       else
    21006         COINUTILS_LIBS="-L`cd ../CoinUtils; pwd` $projectlibs"
    21007       fi
    21008     else
    21009       COINUTILS_LIBS=`sed -n -e 's/Libs://p' ../CoinUtils/coinutils-uninstalled.pc`
    21010     fi
    21011     COINUTILS_DATA=`sed -n -e 's/datadir=//gp' ../CoinUtils/coinutils-uninstalled.pc`
    21012 
    21013     REQUIREDPACKAGES="coinutils $REQUIREDPACKAGES"
    21014 
    21015 
    21016 
    21017 cat >>confdefs.h <<\_ACEOF
    21018 #define COIN_HAS_COINUTILS 1
    21019 _ACEOF
    21020 
    21021 
    21022 
    21023     coin_has_coinutils=yes
    21024     echo "$as_me:$LINENO: result: ../CoinUtils" >&5
    21025 echo "${ECHO_T}../CoinUtils" >&6
    21026   else
    21027     echo "$as_me:$LINENO: result: $coin_has_coinutils" >&5
    21028 echo "${ECHO_T}$coin_has_coinutils" >&6
    21029   fi
    21030 else
    21031   echo "$as_me:$LINENO: result: skipping" >&5
    21032 echo "${ECHO_T}skipping" >&6
    21033 fi
    21034 
    21035 #if user did not disable setting of makefile conditional, do it
    21036 
    21037 
    21038 if test $coin_has_coinutils != notGiven &&
    21039                 test $coin_has_coinutils != skipping; then
    21040   COIN_HAS_COINUTILS_TRUE=
    21041   COIN_HAS_COINUTILS_FALSE='#'
    21042 else
    21043   COIN_HAS_COINUTILS_TRUE='#'
    21044   COIN_HAS_COINUTILS_FALSE=
    21045 fi
    21046 
    21047 
    21048 fi
    21049 
    21050 if test $coin_has_coinutils != yes ; then
    21051   { { echo "$as_me:$LINENO: error: Required package CoinUtils not available." >&5
    21052 echo "$as_me: error: Required package CoinUtils not available." >&2;}
    21053    { (exit 1); exit 1; }; }
    21054 fi
    21055 #so if we had to do find Blas and Lapack separately, then add their linker flags to the CoinUtils flags
    21056 #actually the libs may already be included in libCoinUtils, but we may still need the fortran library flags
    21057 COINUTILS_LIBS="$COINUTILS_LIBS $LAPACK_LIBS $BLAS_LIBS"
    2105820964
    2105920965
     
    2116221068    export PKG_CONFIG_PATH
    2116321069  else
    21164     #if 4th argument is given, try fallback - whereby we take the first word from osi as basename for the .pc file
    21165 
    21166 if test x$coin_has_osi != "xyes" ; then
    21167 
    21168 
     21070    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     21071echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     21072
     21073echo "$as_me:$LINENO: checking for COIN-OR module Osi (fallback)" >&5
     21074echo $ECHO_N "checking for COIN-OR module Osi (fallback)... $ECHO_C" >&6
    2116921075
    2117021076coin_has_osi=notGiven
    21171 
    21172 # check if user wants to skip module in any case
    21173 if test x"$COIN_SKIP_PROJECTS" != x; then
    21174   for dir in $COIN_SKIP_PROJECTS; do
    21175     if test $dir = "Osi"; then
    21176       coin_has_osi=skipping
    21177     fi
    21178   done
    21179 fi
    21180 
    2118121077OSI_LIBS=
    2118221078OSI_CFLAGS=
     
    2118421080
    2118521081
    21186 if test $coin_has_osi != "skipping" ; then
    21187   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    21188   if test -r ../Osi/osi-uninstalled.pc ; then
    21189     # read CFLAGS and LIBS from m4_bpatsubst(osi, [ .*], [])-uninstalled.pc file
    21190     # add CYGPATH_W cludge into include flags
    21191     # replace -L${libdir} by absolute path to build directory in linker flags
    21192     # we assume that the build directory is ../Osi/src if this directory exists, otherwise we assume that it is ../Osi
    21193     OSI_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../Osi/osi-uninstalled.pc`
    21194     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../Osi/osi-uninstalled.pc`
    21195     if test "x$projectlibs" != x ; then
    21196       if test -d ../Osi/src ; then
    21197         OSI_LIBS="-L`cd ../Osi/src; pwd` $projectlibs"
     21082# initial list of dependencies is "osi", but we need to filter out version number specifications (= x, <= x, >= x)
     21083projtoprocess="osi"
     21084projprocessed=""
     21085
     21086while test $coin_has_osi = notGiven ; do
     21087  # setup list of projects that need to be processed in the next round
     21088  nextprojtoprocess=""
     21089
     21090  for proj in $projtoprocess ; do
     21091    # if $proj has been processed already, skip this round
     21092    if test "x$projprocessed" != x ; then
     21093      for projdone in $projprocessed ; do
     21094        if test $projdone = $proj ; then
     21095          continue 2
     21096        fi
     21097      done
     21098    fi
     21099
     21100    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     21101    pcfile=""
     21102    save_IFS="$IFS"
     21103    IFS=":"
     21104    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     21105      # 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
     21106      if test -r "$dir/$proj-uninstalled.pc" ; then
     21107        pcfile="$dir/$proj-uninstalled.pc"
     21108        pcfiledir="$dir"
     21109        break
     21110      fi
     21111    done
     21112    IFS="$save_IFS"
     21113
     21114    if test "x$pcfile" != x ; then
     21115      # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21116      projcflags=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' "$pcfile"`
     21117      OSI_CFLAGS="$projcflags $OSI_CFLAGS"
     21118
     21119      # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21120      # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21121      projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21122      if test "x$projlibs" != x ; then
     21123        if test -d "${pcfiledir}/src" ; then
     21124          projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21125        else
     21126          projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21127        fi
    2119821128      else
    21199         OSI_LIBS="-L`cd ../Osi; pwd` $projectlibs"
     21129        projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    2120021130      fi
     21131      OSI_LIBS="$projlibs $OSI_LIBS"
     21132
     21133      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
     21134      if test "x$projprocessed" = x ; then
     21135        OSI_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
     21136      fi
     21137
     21138      # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
     21139      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
     21140      nextprojtoprocess="$nextprojtoprocess $projrequires"
     21141
     21142      # remember that we have processed $proj
     21143      projprocessed="$projprocessed $proj"
     21144
    2120121145    else
    21202       OSI_LIBS=`sed -n -e 's/Libs://p' ../Osi/osi-uninstalled.pc`
     21146      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     21147echo "${ECHO_T}no, dependency $proj not available" >&6
     21148      break 2
    2120321149    fi
    21204     OSI_DATA=`sed -n -e 's/datadir=//gp' ../Osi/osi-uninstalled.pc`
    21205 
     21150
     21151  done
     21152
     21153  projtoprocess="$nextprojtoprocess"
     21154
     21155  if test "x$projtoprocess" = x ; then
     21156    coin_has_osi=yes
     21157    echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
     21158echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
    2120621159
    2120721160
     
    2121221165
    2121321166
    21214 
    21215     coin_has_osi=yes
    21216     echo "$as_me:$LINENO: result: ../Osi" >&5
    21217 echo "${ECHO_T}../Osi" >&6
    21218   else
    21219     echo "$as_me:$LINENO: result: $coin_has_osi" >&5
    21220 echo "${ECHO_T}$coin_has_osi" >&6
    21221   fi
    21222 else
    21223   echo "$as_me:$LINENO: result: skipping" >&5
    21224 echo "${ECHO_T}skipping" >&6
    21225 fi
    21226 
    21227 #if user did not disable setting of makefile conditional, do it
     21167    if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21168    if test -n "$OSI_CFLAGS" ; then
     21169      { echo "$as_me:$LINENO: Osi CFLAGS are $OSI_CFLAGS" >&5
     21170echo "$as_me: Osi CFLAGS are $OSI_CFLAGS" >&6;}
     21171    fi
     21172    if test -n "$OSI_LIBS" ; then
     21173      { echo "$as_me:$LINENO: Osi LIBS   are $OSI_LIBS" >&5
     21174echo "$as_me: Osi LIBS   are $OSI_LIBS" >&6;}
     21175    fi
     21176    if test -n "$OSI_DATA" ; then
     21177      { echo "$as_me:$LINENO: Osi DATA   is  $OSI_DATA" >&5
     21178echo "$as_me: Osi DATA   is  $OSI_DATA" >&6;}
     21179    fi
     21180    fi
     21181  fi
     21182done
     21183
    2122821184
    2122921185
     
    2123721193fi
    2123821194
    21239 
    21240 fi
    2124121195
    2124221196
     
    2139021344    export PKG_CONFIG_PATH
    2139121345  else
    21392     #if 4th argument is given, try fallback - whereby we take the first word from osi-unittests as basename for the .pc file
    21393 
    21394 if test x$coin_has_ositests != "xyes" ; then
    21395 
    21396 
     21346    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     21347echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     21348
     21349echo "$as_me:$LINENO: checking for COIN-OR module OsiTests (fallback)" >&5
     21350echo $ECHO_N "checking for COIN-OR module OsiTests (fallback)... $ECHO_C" >&6
    2139721351
    2139821352coin_has_ositests=notGiven
    21399 
    21400 # check if user wants to skip module in any case
    21401 if test x"$COIN_SKIP_PROJECTS" != x; then
    21402   for dir in $COIN_SKIP_PROJECTS; do
    21403     if test $dir = "OsiTests"; then
    21404       coin_has_ositests=skipping
    21405     fi
    21406   done
    21407 fi
    21408 
    2140921353OSITESTS_LIBS=
    2141021354OSITESTS_CFLAGS=
     
    2141221356
    2141321357
    21414 if test $coin_has_ositests != "skipping" ; then
    21415   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    21416   if test -r ../Osi/osi-unittests-uninstalled.pc ; then
    21417     # read CFLAGS and LIBS from m4_bpatsubst(osi-unittests, [ .*], [])-uninstalled.pc file
    21418     # add CYGPATH_W cludge into include flags
    21419     # replace -L${libdir} by absolute path to build directory in linker flags
    21420     # we assume that the build directory is ../Osi/src if this directory exists, otherwise we assume that it is ../Osi
    21421     OSITESTS_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../Osi/osi-unittests-uninstalled.pc`
    21422     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../Osi/osi-unittests-uninstalled.pc`
    21423     if test "x$projectlibs" != x ; then
    21424       if test -d ../Osi/src ; then
    21425         OSITESTS_LIBS="-L`cd ../Osi/src; pwd` $projectlibs"
     21358# initial list of dependencies is "osi-unittests", but we need to filter out version number specifications (= x, <= x, >= x)
     21359projtoprocess="osi-unittests"
     21360projprocessed=""
     21361
     21362while test $coin_has_ositests = notGiven ; do
     21363  # setup list of projects that need to be processed in the next round
     21364  nextprojtoprocess=""
     21365
     21366  for proj in $projtoprocess ; do
     21367    # if $proj has been processed already, skip this round
     21368    if test "x$projprocessed" != x ; then
     21369      for projdone in $projprocessed ; do
     21370        if test $projdone = $proj ; then
     21371          continue 2
     21372        fi
     21373      done
     21374    fi
     21375
     21376    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     21377    pcfile=""
     21378    save_IFS="$IFS"
     21379    IFS=":"
     21380    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     21381      # 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
     21382      if test -r "$dir/$proj-uninstalled.pc" ; then
     21383        pcfile="$dir/$proj-uninstalled.pc"
     21384        pcfiledir="$dir"
     21385        break
     21386      fi
     21387    done
     21388    IFS="$save_IFS"
     21389
     21390    if test "x$pcfile" != x ; then
     21391      # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21392      projcflags=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' "$pcfile"`
     21393      OSITESTS_CFLAGS="$projcflags $OSITESTS_CFLAGS"
     21394
     21395      # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21396      # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21397      projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21398      if test "x$projlibs" != x ; then
     21399        if test -d "${pcfiledir}/src" ; then
     21400          projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21401        else
     21402          projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21403        fi
    2142621404      else
    21427         OSITESTS_LIBS="-L`cd ../Osi; pwd` $projectlibs"
     21405        projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    2142821406      fi
     21407      OSITESTS_LIBS="$projlibs $OSITESTS_LIBS"
     21408
     21409      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
     21410      if test "x$projprocessed" = x ; then
     21411        OSITESTS_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
     21412      fi
     21413
     21414      # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
     21415      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
     21416      nextprojtoprocess="$nextprojtoprocess $projrequires"
     21417
     21418      # remember that we have processed $proj
     21419      projprocessed="$projprocessed $proj"
     21420
    2142921421    else
    21430       OSITESTS_LIBS=`sed -n -e 's/Libs://p' ../Osi/osi-unittests-uninstalled.pc`
     21422      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     21423echo "${ECHO_T}no, dependency $proj not available" >&6
     21424      break 2
    2143121425    fi
    21432     OSITESTS_DATA=`sed -n -e 's/datadir=//gp' ../Osi/osi-unittests-uninstalled.pc`
    21433 
     21426
     21427  done
     21428
     21429  projtoprocess="$nextprojtoprocess"
     21430
     21431  if test "x$projtoprocess" = x ; then
     21432    coin_has_ositests=yes
     21433    echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
     21434echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
    2143421435
    2143521436
     
    2144021441
    2144121442
    21442 
    21443     coin_has_ositests=yes
    21444     echo "$as_me:$LINENO: result: ../Osi" >&5
    21445 echo "${ECHO_T}../Osi" >&6
    21446   else
    21447     echo "$as_me:$LINENO: result: $coin_has_ositests" >&5
    21448 echo "${ECHO_T}$coin_has_ositests" >&6
    21449   fi
    21450 else
    21451   echo "$as_me:$LINENO: result: skipping" >&5
    21452 echo "${ECHO_T}skipping" >&6
    21453 fi
    21454 
    21455 #if user did not disable setting of makefile conditional, do it
     21443    if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21444    if test -n "$OSITESTS_CFLAGS" ; then
     21445      { echo "$as_me:$LINENO: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&5
     21446echo "$as_me: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&6;}
     21447    fi
     21448    if test -n "$OSITESTS_LIBS" ; then
     21449      { echo "$as_me:$LINENO: OsiTests LIBS   are $OSITESTS_LIBS" >&5
     21450echo "$as_me: OsiTests LIBS   are $OSITESTS_LIBS" >&6;}
     21451    fi
     21452    if test -n "$OSITESTS_DATA" ; then
     21453      { echo "$as_me:$LINENO: OsiTests DATA   is  $OSITESTS_DATA" >&5
     21454echo "$as_me: OsiTests DATA   is  $OSITESTS_DATA" >&6;}
     21455    fi
     21456    fi
     21457  fi
     21458done
     21459
    2145621460
    2145721461
     
    2146521469fi
    2146621470
    21467 
    21468 fi
    2146921471
    2147021472
     
    2161821620    export PKG_CONFIG_PATH
    2161921621  else
    21620     #if 4th argument is given, try fallback - whereby we take the first word from coindatasample as basename for the .pc file
    21621 
    21622 if test x$coin_has_sample != "xyes" ; then
    21623 
    21624 
     21622    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     21623echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     21624
     21625echo "$as_me:$LINENO: checking for COIN-OR module Sample (fallback)" >&5
     21626echo $ECHO_N "checking for COIN-OR module Sample (fallback)... $ECHO_C" >&6
    2162521627
    2162621628coin_has_sample=notGiven
    21627 
    21628 # check if user wants to skip module in any case
    21629 if test x"$COIN_SKIP_PROJECTS" != x; then
    21630   for dir in $COIN_SKIP_PROJECTS; do
    21631     if test $dir = "Sample"; then
    21632       coin_has_sample=skipping
    21633     fi
    21634   done
    21635 fi
    21636 
    2163721629SAMPLE_LIBS=
    2163821630SAMPLE_CFLAGS=
     
    2164021632
    2164121633
    21642 if test $coin_has_sample != "skipping" ; then
    21643   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    21644   if test -r ../Data/Sample/coindatasample-uninstalled.pc ; then
    21645     # read CFLAGS and LIBS from m4_bpatsubst(coindatasample, [ .*], [])-uninstalled.pc file
    21646     # add CYGPATH_W cludge into include flags
    21647     # replace -L${libdir} by absolute path to build directory in linker flags
    21648     # we assume that the build directory is ../Data/Sample/src if this directory exists, otherwise we assume that it is ../Data/Sample
    21649     SAMPLE_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../Data/Sample/coindatasample-uninstalled.pc`
    21650     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../Data/Sample/coindatasample-uninstalled.pc`
    21651     if test "x$projectlibs" != x ; then
    21652       if test -d ../Data/Sample/src ; then
    21653         SAMPLE_LIBS="-L`cd ../Data/Sample/src; pwd` $projectlibs"
     21634# initial list of dependencies is "coindatasample", but we need to filter out version number specifications (= x, <= x, >= x)
     21635projtoprocess="coindatasample"
     21636projprocessed=""
     21637
     21638while test $coin_has_sample = notGiven ; do
     21639  # setup list of projects that need to be processed in the next round
     21640  nextprojtoprocess=""
     21641
     21642  for proj in $projtoprocess ; do
     21643    # if $proj has been processed already, skip this round
     21644    if test "x$projprocessed" != x ; then
     21645      for projdone in $projprocessed ; do
     21646        if test $projdone = $proj ; then
     21647          continue 2
     21648        fi
     21649      done
     21650    fi
     21651
     21652    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     21653    pcfile=""
     21654    save_IFS="$IFS"
     21655    IFS=":"
     21656    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     21657      # 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
     21658      if test -r "$dir/$proj-uninstalled.pc" ; then
     21659        pcfile="$dir/$proj-uninstalled.pc"
     21660        pcfiledir="$dir"
     21661        break
     21662      fi
     21663    done
     21664    IFS="$save_IFS"
     21665
     21666    if test "x$pcfile" != x ; then
     21667      # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21668      projcflags=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' "$pcfile"`
     21669      SAMPLE_CFLAGS="$projcflags $SAMPLE_CFLAGS"
     21670
     21671      # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21672      # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21673      projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21674      if test "x$projlibs" != x ; then
     21675        if test -d "${pcfiledir}/src" ; then
     21676          projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21677        else
     21678          projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21679        fi
    2165421680      else
    21655         SAMPLE_LIBS="-L`cd ../Data/Sample; pwd` $projectlibs"
     21681        projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    2165621682      fi
     21683      SAMPLE_LIBS="$projlibs $SAMPLE_LIBS"
     21684
     21685      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
     21686      if test "x$projprocessed" = x ; then
     21687        SAMPLE_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
     21688      fi
     21689
     21690      # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
     21691      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
     21692      nextprojtoprocess="$nextprojtoprocess $projrequires"
     21693
     21694      # remember that we have processed $proj
     21695      projprocessed="$projprocessed $proj"
     21696
    2165721697    else
    21658       SAMPLE_LIBS=`sed -n -e 's/Libs://p' ../Data/Sample/coindatasample-uninstalled.pc`
     21698      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     21699echo "${ECHO_T}no, dependency $proj not available" >&6
     21700      break 2
    2165921701    fi
    21660     SAMPLE_DATA=`sed -n -e 's/datadir=//gp' ../Data/Sample/coindatasample-uninstalled.pc`
    21661 
     21702
     21703  done
     21704
     21705  projtoprocess="$nextprojtoprocess"
     21706
     21707  if test "x$projtoprocess" = x ; then
     21708    coin_has_sample=yes
     21709    echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
     21710echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
    2166221711
    2166321712
     
    2166821717
    2166921718
    21670 
    21671     coin_has_sample=yes
    21672     echo "$as_me:$LINENO: result: ../Data/Sample" >&5
    21673 echo "${ECHO_T}../Data/Sample" >&6
    21674   else
    21675     echo "$as_me:$LINENO: result: $coin_has_sample" >&5
    21676 echo "${ECHO_T}$coin_has_sample" >&6
    21677   fi
    21678 else
    21679   echo "$as_me:$LINENO: result: skipping" >&5
    21680 echo "${ECHO_T}skipping" >&6
    21681 fi
    21682 
    21683 #if user did not disable setting of makefile conditional, do it
     21719    if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21720    if test -n "$SAMPLE_CFLAGS" ; then
     21721      { echo "$as_me:$LINENO: Sample CFLAGS are $SAMPLE_CFLAGS" >&5
     21722echo "$as_me: Sample CFLAGS are $SAMPLE_CFLAGS" >&6;}
     21723    fi
     21724    if test -n "$SAMPLE_LIBS" ; then
     21725      { echo "$as_me:$LINENO: Sample LIBS   are $SAMPLE_LIBS" >&5
     21726echo "$as_me: Sample LIBS   are $SAMPLE_LIBS" >&6;}
     21727    fi
     21728    if test -n "$SAMPLE_DATA" ; then
     21729      { echo "$as_me:$LINENO: Sample DATA   is  $SAMPLE_DATA" >&5
     21730echo "$as_me: Sample DATA   is  $SAMPLE_DATA" >&6;}
     21731    fi
     21732    fi
     21733  fi
     21734done
     21735
    2168421736
    2168521737
     
    2169321745fi
    2169421746
    21695 
    21696 fi
    2169721747
    2169821748
     
    2184621896    export PKG_CONFIG_PATH
    2184721897  else
    21848     #if 4th argument is given, try fallback - whereby we take the first word from coindatanetlib as basename for the .pc file
    21849 
    21850 if test x$coin_has_netlib != "xyes" ; then
    21851 
    21852 
     21898    echo "$as_me:$LINENO: result: skipped check via pkg-config, redirect to fallback" >&5
     21899echo "${ECHO_T}skipped check via pkg-config, redirect to fallback" >&6
     21900
     21901echo "$as_me:$LINENO: checking for COIN-OR module Netlib (fallback)" >&5
     21902echo $ECHO_N "checking for COIN-OR module Netlib (fallback)... $ECHO_C" >&6
    2185321903
    2185421904coin_has_netlib=notGiven
    21855 
    21856 # check if user wants to skip module in any case
    21857 if test x"$COIN_SKIP_PROJECTS" != x; then
    21858   for dir in $COIN_SKIP_PROJECTS; do
    21859     if test $dir = "Netlib"; then
    21860       coin_has_netlib=skipping
    21861     fi
    21862   done
    21863 fi
    21864 
    2186521905NETLIB_LIBS=
    2186621906NETLIB_CFLAGS=
     
    2186821908
    2186921909
    21870 if test $coin_has_netlib != "skipping" ; then
    21871   # if the project is available and configured, then a project-uninstalled.pc file should have been created
    21872   if test -r ../Data/Netlib/coindatanetlib-uninstalled.pc ; then
    21873     # read CFLAGS and LIBS from m4_bpatsubst(coindatanetlib, [ .*], [])-uninstalled.pc file
    21874     # add CYGPATH_W cludge into include flags
    21875     # replace -L${libdir} by absolute path to build directory in linker flags
    21876     # we assume that the build directory is ../Data/Netlib/src if this directory exists, otherwise we assume that it is ../Data/Netlib
    21877     NETLIB_CFLAGS=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' ../Data/Netlib/coindatanetlib-uninstalled.pc`
    21878     projectlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' ../Data/Netlib/coindatanetlib-uninstalled.pc`
    21879     if test "x$projectlibs" != x ; then
    21880       if test -d ../Data/Netlib/src ; then
    21881         NETLIB_LIBS="-L`cd ../Data/Netlib/src; pwd` $projectlibs"
     21910# initial list of dependencies is "coindatanetlib", but we need to filter out version number specifications (= x, <= x, >= x)
     21911projtoprocess="coindatanetlib"
     21912projprocessed=""
     21913
     21914while test $coin_has_netlib = notGiven ; do
     21915  # setup list of projects that need to be processed in the next round
     21916  nextprojtoprocess=""
     21917
     21918  for proj in $projtoprocess ; do
     21919    # if $proj has been processed already, skip this round
     21920    if test "x$projprocessed" != x ; then
     21921      for projdone in $projprocessed ; do
     21922        if test $projdone = $proj ; then
     21923          continue 2
     21924        fi
     21925      done
     21926    fi
     21927
     21928    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
     21929    pcfile=""
     21930    save_IFS="$IFS"
     21931    IFS=":"
     21932    for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do
     21933      # 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
     21934      if test -r "$dir/$proj-uninstalled.pc" ; then
     21935        pcfile="$dir/$proj-uninstalled.pc"
     21936        pcfiledir="$dir"
     21937        break
     21938      fi
     21939    done
     21940    IFS="$save_IFS"
     21941
     21942    if test "x$pcfile" != x ; then
     21943      # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21944      projcflags=`sed -n -e 's/Cflags://' -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/gp' "$pcfile"`
     21945      NETLIB_CFLAGS="$projcflags $NETLIB_CFLAGS"
     21946
     21947      # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21948      # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21949      projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21950      if test "x$projlibs" != x ; then
     21951        if test -d "${pcfiledir}/src" ; then
     21952          projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21953        else
     21954          projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21955        fi
    2188221956      else
    21883         NETLIB_LIBS="-L`cd ../Data/Netlib; pwd` $projectlibs"
     21957        projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    2188421958      fi
     21959      NETLIB_LIBS="$projlibs $NETLIB_LIBS"
     21960
     21961      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
     21962      if test "x$projprocessed" = x ; then
     21963        NETLIB_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
     21964      fi
     21965
     21966      # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
     21967      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
     21968      nextprojtoprocess="$nextprojtoprocess $projrequires"
     21969
     21970      # remember that we have processed $proj
     21971      projprocessed="$projprocessed $proj"
     21972
    2188521973    else
    21886       NETLIB_LIBS=`sed -n -e 's/Libs://p' ../Data/Netlib/coindatanetlib-uninstalled.pc`
     21974      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
     21975echo "${ECHO_T}no, dependency $proj not available" >&6
     21976      break 2
    2188721977    fi
    21888     NETLIB_DATA=`sed -n -e 's/datadir=//gp' ../Data/Netlib/coindatanetlib-uninstalled.pc`
    21889 
     21978
     21979  done
     21980
     21981  projtoprocess="$nextprojtoprocess"
     21982
     21983  if test "x$projtoprocess" = x ; then
     21984    coin_has_netlib=yes
     21985    echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
     21986echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
    2189021987
    2189121988
     
    2189621993
    2189721994
    21898 
    21899     coin_has_netlib=yes
    21900     echo "$as_me:$LINENO: result: ../Data/Netlib" >&5
    21901 echo "${ECHO_T}../Data/Netlib" >&6
    21902   else
    21903     echo "$as_me:$LINENO: result: $coin_has_netlib" >&5
    21904 echo "${ECHO_T}$coin_has_netlib" >&6
    21905   fi
    21906 else
    21907   echo "$as_me:$LINENO: result: skipping" >&5
    21908 echo "${ECHO_T}skipping" >&6
    21909 fi
    21910 
    21911 #if user did not disable setting of makefile conditional, do it
     21995    if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21996    if test -n "$NETLIB_CFLAGS" ; then
     21997      { echo "$as_me:$LINENO: Netlib CFLAGS are $NETLIB_CFLAGS" >&5
     21998echo "$as_me: Netlib CFLAGS are $NETLIB_CFLAGS" >&6;}
     21999    fi
     22000    if test -n "$NETLIB_LIBS" ; then
     22001      { echo "$as_me:$LINENO: Netlib LIBS   are $NETLIB_LIBS" >&5
     22002echo "$as_me: Netlib LIBS   are $NETLIB_LIBS" >&6;}
     22003    fi
     22004    if test -n "$NETLIB_DATA" ; then
     22005      { echo "$as_me:$LINENO: Netlib DATA   is  $NETLIB_DATA" >&5
     22006echo "$as_me: Netlib DATA   is  $NETLIB_DATA" >&6;}
     22007    fi
     22008    fi
     22009  fi
     22010done
     22011
    2191222012
    2191322013
     
    2192122021fi
    2192222022
    21923 
    21924 fi
    2192522023
    2192622024
  • trunk/Clp/configure.ac

    r1564 r1580  
    5858
    5959AC_COIN_HAS_MODULE(CoinUtils, [coinutils = trunk])
    60 if test $coin_has_coinutils != yes ; then
    61   #if we have to use the fallback routines, then obviously it will not find CoinUtils dependencies
    62   #thus, we check whether ThirdParty/Blas and ThirdParty/Lapack have been setup and
    63   #assume that if present then they are dependencies of CoinUtils
    64   AC_COIN_HAS_MODULE_FALLBACK(Blas,   [coinblas],   [../ThirdParty/Blas],   [required=0 dodefine=0 doconditional=0])
    65   AC_COIN_HAS_MODULE_FALLBACK(Lapack, [coinlapack], [../ThirdParty/Lapack], [required=0 dodefine=0 doconditional=0])
    66 fi
    67 AC_COIN_HAS_MODULE_FALLBACK(CoinUtils, [coinutils], [../CoinUtils])
    68 if test $coin_has_coinutils != yes ; then
    69   AC_MSG_ERROR([Required package CoinUtils not available.])
    70 fi
    71 #so if we had to do find Blas and Lapack separately, then add their linker flags to the CoinUtils flags
    72 #actually the libs may already be included in libCoinUtils, but we may still need the fortran library flags
    73 COINUTILS_LIBS="$COINUTILS_LIBS $LAPACK_LIBS $BLAS_LIBS"
    74 
    75 AC_COIN_HAS_MODULE(Osi,      [osi],            [required=0], [../Osi])
    76 AC_COIN_HAS_MODULE(OsiTests, [osi-unittests],  [required=0], [../Osi])
    77 AC_COIN_HAS_MODULE(Sample,   [coindatasample], [required=0], [../Data/Sample])
    78 AC_COIN_HAS_MODULE(Netlib,   [coindatanetlib], [required=0], [../Data/Netlib])
     60AC_COIN_HAS_MODULE(Osi,       [osi],            [required=0], [../Osi])
     61AC_COIN_HAS_MODULE(OsiTests,  [osi-unittests],  [required=0], [../Osi])
     62AC_COIN_HAS_MODULE(Sample,    [coindatasample], [required=0], [../Data/Sample])
     63AC_COIN_HAS_MODULE(Netlib,    [coindatanetlib], [required=0], [../Data/Netlib])
    7964
    8065#############################################################################
Note: See TracChangeset for help on using the changeset viewer.