Changeset 1536 for trunk/Cbc


Ignore:
Timestamp:
Nov 25, 2010 11:58:31 AM (9 years ago)
Author:
lou
Message:

Correct typo in configure.ac, miblib3 -> miplib3.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

    • Property svn:externals
      •  

        old new  
        1111Osi               https://projects.coin-or.org/svn/Osi/trunk/Osi
        1212Vol               https://projects.coin-or.org/svn/Vol/trunk/Vol
        13 
  • trunk/Cbc/configure

    r1531 r1536  
    2088120881# initial list of dependencies is "cgl osi coinutils", but we need to filter out version number specifications (= x, <= x, >= x)
    2088220882projtoprocess="cgl osi coinutils"
    20883 projprocessed=""
    20884 
    20885 while test $coin_has_coindepend = notGiven ; do
    20886   # setup list of projects that need to be processed in the next round
    20887   nextprojtoprocess=""
     20883
     20884# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     20885# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     20886# also, we setup the DATA variable
     20887allproj=""
     20888allpcfiles=""
     20889while test "x$projtoprocess" != x ; do
    2088820890
    2088920891  for proj in $projtoprocess ; do
    20890     # if $proj has been processed already, skip this round
    20891     if test "x$projprocessed" != x ; then
    20892       for projdone in $projprocessed ; do
    20893         if test $projdone = $proj ; then
    20894           continue 2
    20895         fi
    20896       done
    20897     fi
    20898 
    2089920892    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2090020893    pcfile=""
     
    2090520898      if test -r "$dir/$proj-uninstalled.pc" ; then
    2090620899        pcfile="$dir/$proj-uninstalled.pc"
    20907         pcfiledir="$dir"
    2090820900        break
    2090920901      fi
     
    2091220904
    2091320905    if test "x$pcfile" != x ; then
    20914       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    20915       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    20916       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    20917       COINDEPEND_CFLAGS="$projcflags $COINDEPEND_CFLAGS"
    20918 
    20919       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    20920       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    20921       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    20922       if test "x$projlibs" != x ; then
    20923         if test -d "${pcfiledir}/src" ; then
    20924           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    20925         else
    20926           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    20927         fi
    20928       else
    20929         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    20930       fi
    20931       COINDEPEND_LIBS="$COINDEPEND_LIBS $projlibs"
     20906      # read dependencies from $pcfile and filter it
     20907      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     20908
     20909      # add projrequires to the front of the list of projects that have to be processed next
     20910      # at the same time, remove $proj from this list
     20911      projtoprocess=${projtoprocess/$proj/$projrequires}
    2093220912
    2093320913      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    20934       if test "x$projprocessed" = x ; then
     20914      if test "x$allproj" = x ; then
    2093520915        COINDEPEND_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2093620916      fi
    2093720917
    20938       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    20939       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    20940       nextprojtoprocess="$nextprojtoprocess $projrequires"
    20941 
    20942       # remember that we have processed $proj
    20943       projprocessed="$projprocessed $proj"
     20918      allproj="$allproj $proj"
     20919      allpcfiles="$pcfile:$allpcfiles"
    2094420920
    2094520921    else
    2094620922      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2094720923echo "${ECHO_T}no, dependency $proj not available" >&6
     20924      allproj=fail
    2094820925      break 2
    2094920926    fi
    2095020927
     20928    break
    2095120929  done
    2095220930
    20953   projtoprocess="$nextprojtoprocess"
    20954 
    20955   # if there are no more projects to search for, finish up
    20956   if test "x$projtoprocess" = x ; then
    20957     coin_has_coindepend=yes
    20958     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    20959 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     20931  # remove spaces on begin of $projtoprocess
     20932  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     20933
     20934done
     20935
     20936if test "$allproj" != fail ; then
     20937
     20938  # now go through the list of .pc files and assemble compiler and linker flags
     20939  # important is here to obey the reverse order that has been setup before,
     20940  # since then libraries that are required by several others should be after these other libraries
     20941  pcfilesprocessed=""
     20942
     20943  save_IFS="$IFS"
     20944  IFS=":"
     20945  for pcfile in $allpcfiles ; do
     20946
     20947    # if $pcfile has been processed already, skip this round
     20948    if test "x$pcfilesprocessed" != x ; then
     20949      for pcfiledone in $pcfilesprocessed ; do
     20950        if test "$pcfiledone" = "$pcfile" ; then
     20951          continue 2
     20952        fi
     20953      done
     20954    fi
     20955
     20956    # reconstruct the directory where the .pc file is located
     20957    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     20958
     20959    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     20960    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     20961    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     20962    COINDEPEND_CFLAGS="$projcflags $COINDEPEND_CFLAGS"
     20963
     20964    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     20965    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     20966    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     20967    if test "x$projlibs" != x ; then
     20968      if test -d "${pcfiledir}/src" ; then
     20969        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     20970      else
     20971        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     20972      fi
     20973    else
     20974      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     20975    fi
     20976    COINDEPEND_LIBS="$projlibs $COINDEPEND_LIBS"
     20977
     20978    # remember that we have processed $pcfile
     20979    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     20980
     20981  done
     20982  IFS="$save_IFS"
     20983
     20984  # finish up
     20985  coin_has_coindepend=yes
     20986  echo "$as_me:$LINENO: result: yes" >&5
     20987echo "${ECHO_T}yes" >&6
    2096020988
    2096120989cat >>confdefs.h <<\_ACEOF
     
    2096520993
    2096620994
    20967       CBCLIB_PCREQUIRES="cgl osi coinutils $CBCLIB_PCREQUIRES"
    20968       CBCLIB_CFLAGS="$COINDEPEND_CFLAGS $CBCLIB_CFLAGS"
    20969       CBCLIB_LIBS="$COINDEPEND_LIBS $CBCLIB_LIBS"
    20970 
    20971       CBCGENERIC_PCREQUIRES="cgl osi coinutils $CBCGENERIC_PCREQUIRES"
    20972       CBCGENERIC_CFLAGS="$COINDEPEND_CFLAGS $CBCGENERIC_CFLAGS"
    20973       CBCGENERIC_LIBS="$COINDEPEND_LIBS $CBCGENERIC_LIBS"
    20974 
    20975 
    20976     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    20977       if test -n "$COINDEPEND_CFLAGS" ; then
    20978         { echo "$as_me:$LINENO: CoinDepend CFLAGS are $COINDEPEND_CFLAGS" >&5
     20995    CBCLIB_PCREQUIRES="cgl osi coinutils $CBCLIB_PCREQUIRES"
     20996    CBCLIB_CFLAGS="$COINDEPEND_CFLAGS $CBCLIB_CFLAGS"
     20997    CBCLIB_LIBS="$COINDEPEND_LIBS $CBCLIB_LIBS"
     20998
     20999    CBCGENERIC_PCREQUIRES="cgl osi coinutils $CBCGENERIC_PCREQUIRES"
     21000    CBCGENERIC_CFLAGS="$COINDEPEND_CFLAGS $CBCGENERIC_CFLAGS"
     21001    CBCGENERIC_LIBS="$COINDEPEND_LIBS $CBCGENERIC_LIBS"
     21002
     21003
     21004  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21005    if test -n "$COINDEPEND_CFLAGS" ; then
     21006      { echo "$as_me:$LINENO: CoinDepend CFLAGS are $COINDEPEND_CFLAGS" >&5
    2097921007echo "$as_me: CoinDepend CFLAGS are $COINDEPEND_CFLAGS" >&6;}
    20980       fi
    20981       if test -n "$COINDEPEND_LIBS" ; then
    20982         { echo "$as_me:$LINENO: CoinDepend LIBS   are $COINDEPEND_LIBS" >&5
     21008    fi
     21009    if test -n "$COINDEPEND_LIBS" ; then
     21010      { echo "$as_me:$LINENO: CoinDepend LIBS   are $COINDEPEND_LIBS" >&5
    2098321011echo "$as_me: CoinDepend LIBS   are $COINDEPEND_LIBS" >&6;}
    20984       fi
    20985       if test -n "$COINDEPEND_DATA" ; then
    20986         { echo "$as_me:$LINENO: CoinDepend DATA   is  $COINDEPEND_DATA" >&5
     21012    fi
     21013    if test -n "$COINDEPEND_DATA" ; then
     21014      { echo "$as_me:$LINENO: CoinDepend DATA   is  $COINDEPEND_DATA" >&5
    2098721015echo "$as_me: CoinDepend DATA   is  $COINDEPEND_DATA" >&6;}
    20988       fi
    20989 
    20990         { echo "$as_me:$LINENO: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&5
     21016    fi
     21017
     21018      { echo "$as_me:$LINENO: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&5
    2099121019echo "$as_me: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&6;}
    20992         { echo "$as_me:$LINENO: CbcLib LIBS   are $CBCLIB_LIBS" >&5
     21020      { echo "$as_me:$LINENO: CbcLib LIBS   are $CBCLIB_LIBS" >&5
    2099321021echo "$as_me: CbcLib LIBS   are $CBCLIB_LIBS" >&6;}
    2099421022
    20995         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     21023      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2099621024echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    20997         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     21025      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2099821026echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2099921027
    21000     fi
    2100121028  fi
    21002 done
     21029
     21030fi
    2100321031
    2100421032
     
    2123221260# initial list of dependencies is "osi-clp", but we need to filter out version number specifications (= x, <= x, >= x)
    2123321261projtoprocess="osi-clp"
    21234 projprocessed=""
    21235 
    21236 while test $coin_has_clp = notGiven ; do
    21237   # setup list of projects that need to be processed in the next round
    21238   nextprojtoprocess=""
     21262
     21263# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     21264# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     21265# also, we setup the DATA variable
     21266allproj=""
     21267allpcfiles=""
     21268while test "x$projtoprocess" != x ; do
    2123921269
    2124021270  for proj in $projtoprocess ; do
    21241     # if $proj has been processed already, skip this round
    21242     if test "x$projprocessed" != x ; then
    21243       for projdone in $projprocessed ; do
    21244         if test $projdone = $proj ; then
    21245           continue 2
    21246         fi
    21247       done
    21248     fi
    21249 
    2125021271    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2125121272    pcfile=""
     
    2125621277      if test -r "$dir/$proj-uninstalled.pc" ; then
    2125721278        pcfile="$dir/$proj-uninstalled.pc"
    21258         pcfiledir="$dir"
    2125921279        break
    2126021280      fi
     
    2126321283
    2126421284    if test "x$pcfile" != x ; then
    21265       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    21266       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    21267       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    21268       CLP_CFLAGS="$projcflags $CLP_CFLAGS"
    21269 
    21270       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    21271       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    21272       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    21273       if test "x$projlibs" != x ; then
    21274         if test -d "${pcfiledir}/src" ; then
    21275           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    21276         else
    21277           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    21278         fi
    21279       else
    21280         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    21281       fi
    21282       CLP_LIBS="$CLP_LIBS $projlibs"
     21285      # read dependencies from $pcfile and filter it
     21286      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     21287
     21288      # add projrequires to the front of the list of projects that have to be processed next
     21289      # at the same time, remove $proj from this list
     21290      projtoprocess=${projtoprocess/$proj/$projrequires}
    2128321291
    2128421292      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    21285       if test "x$projprocessed" = x ; then
     21293      if test "x$allproj" = x ; then
    2128621294        CLP_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2128721295      fi
    2128821296
    21289       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    21290       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    21291       nextprojtoprocess="$nextprojtoprocess $projrequires"
    21292 
    21293       # remember that we have processed $proj
    21294       projprocessed="$projprocessed $proj"
     21297      allproj="$allproj $proj"
     21298      allpcfiles="$pcfile:$allpcfiles"
    2129521299
    2129621300    else
    2129721301      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2129821302echo "${ECHO_T}no, dependency $proj not available" >&6
     21303      allproj=fail
    2129921304      break 2
    2130021305    fi
    2130121306
     21307    break
    2130221308  done
    2130321309
    21304   projtoprocess="$nextprojtoprocess"
    21305 
    21306   # if there are no more projects to search for, finish up
    21307   if test "x$projtoprocess" = x ; then
    21308     coin_has_clp=yes
    21309     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    21310 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     21310  # remove spaces on begin of $projtoprocess
     21311  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     21312
     21313done
     21314
     21315if test "$allproj" != fail ; then
     21316
     21317  # now go through the list of .pc files and assemble compiler and linker flags
     21318  # important is here to obey the reverse order that has been setup before,
     21319  # since then libraries that are required by several others should be after these other libraries
     21320  pcfilesprocessed=""
     21321
     21322  save_IFS="$IFS"
     21323  IFS=":"
     21324  for pcfile in $allpcfiles ; do
     21325
     21326    # if $pcfile has been processed already, skip this round
     21327    if test "x$pcfilesprocessed" != x ; then
     21328      for pcfiledone in $pcfilesprocessed ; do
     21329        if test "$pcfiledone" = "$pcfile" ; then
     21330          continue 2
     21331        fi
     21332      done
     21333    fi
     21334
     21335    # reconstruct the directory where the .pc file is located
     21336    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     21337
     21338    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21339    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     21340    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     21341    CLP_CFLAGS="$projcflags $CLP_CFLAGS"
     21342
     21343    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21344    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21345    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21346    if test "x$projlibs" != x ; then
     21347      if test -d "${pcfiledir}/src" ; then
     21348        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21349      else
     21350        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21351      fi
     21352    else
     21353      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     21354    fi
     21355    CLP_LIBS="$projlibs $CLP_LIBS"
     21356
     21357    # remember that we have processed $pcfile
     21358    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     21359
     21360  done
     21361  IFS="$save_IFS"
     21362
     21363  # finish up
     21364  coin_has_clp=yes
     21365  echo "$as_me:$LINENO: result: yes" >&5
     21366echo "${ECHO_T}yes" >&6
    2131121367
    2131221368cat >>confdefs.h <<\_ACEOF
     
    2131621372
    2131721373
    21318       CBCLIB_PCREQUIRES="osi-clp $CBCLIB_PCREQUIRES"
    21319       CBCLIB_CFLAGS="$CLP_CFLAGS $CBCLIB_CFLAGS"
    21320       CBCLIB_LIBS="$CLP_LIBS $CBCLIB_LIBS"
    21321 
    21322       CBCGENERIC_PCREQUIRES="osi-clp $CBCGENERIC_PCREQUIRES"
    21323       CBCGENERIC_CFLAGS="$CLP_CFLAGS $CBCGENERIC_CFLAGS"
    21324       CBCGENERIC_LIBS="$CLP_LIBS $CBCGENERIC_LIBS"
    21325 
    21326 
    21327     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    21328       if test -n "$CLP_CFLAGS" ; then
    21329         { echo "$as_me:$LINENO: Clp CFLAGS are $CLP_CFLAGS" >&5
     21374    CBCLIB_PCREQUIRES="osi-clp $CBCLIB_PCREQUIRES"
     21375    CBCLIB_CFLAGS="$CLP_CFLAGS $CBCLIB_CFLAGS"
     21376    CBCLIB_LIBS="$CLP_LIBS $CBCLIB_LIBS"
     21377
     21378    CBCGENERIC_PCREQUIRES="osi-clp $CBCGENERIC_PCREQUIRES"
     21379    CBCGENERIC_CFLAGS="$CLP_CFLAGS $CBCGENERIC_CFLAGS"
     21380    CBCGENERIC_LIBS="$CLP_LIBS $CBCGENERIC_LIBS"
     21381
     21382
     21383  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21384    if test -n "$CLP_CFLAGS" ; then
     21385      { echo "$as_me:$LINENO: Clp CFLAGS are $CLP_CFLAGS" >&5
    2133021386echo "$as_me: Clp CFLAGS are $CLP_CFLAGS" >&6;}
    21331       fi
    21332       if test -n "$CLP_LIBS" ; then
    21333         { echo "$as_me:$LINENO: Clp LIBS   are $CLP_LIBS" >&5
     21387    fi
     21388    if test -n "$CLP_LIBS" ; then
     21389      { echo "$as_me:$LINENO: Clp LIBS   are $CLP_LIBS" >&5
    2133421390echo "$as_me: Clp LIBS   are $CLP_LIBS" >&6;}
    21335       fi
    21336       if test -n "$CLP_DATA" ; then
    21337         { echo "$as_me:$LINENO: Clp DATA   is  $CLP_DATA" >&5
     21391    fi
     21392    if test -n "$CLP_DATA" ; then
     21393      { echo "$as_me:$LINENO: Clp DATA   is  $CLP_DATA" >&5
    2133821394echo "$as_me: Clp DATA   is  $CLP_DATA" >&6;}
    21339       fi
    21340 
    21341         { echo "$as_me:$LINENO: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&5
     21395    fi
     21396
     21397      { echo "$as_me:$LINENO: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&5
    2134221398echo "$as_me: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&6;}
    21343         { echo "$as_me:$LINENO: CbcLib LIBS   are $CBCLIB_LIBS" >&5
     21399      { echo "$as_me:$LINENO: CbcLib LIBS   are $CBCLIB_LIBS" >&5
    2134421400echo "$as_me: CbcLib LIBS   are $CBCLIB_LIBS" >&6;}
    2134521401
    21346         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     21402      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2134721403echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    21348         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     21404      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2134921405echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2135021406
    21351     fi
    2135221407  fi
    21353 done
     21408
     21409fi
    2135421410
    2135521411
     
    2155721613# initial list of dependencies is "osi-unittests", but we need to filter out version number specifications (= x, <= x, >= x)
    2155821614projtoprocess="osi-unittests"
    21559 projprocessed=""
    21560 
    21561 while test $coin_has_ositests = notGiven ; do
    21562   # setup list of projects that need to be processed in the next round
    21563   nextprojtoprocess=""
     21615
     21616# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     21617# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     21618# also, we setup the DATA variable
     21619allproj=""
     21620allpcfiles=""
     21621while test "x$projtoprocess" != x ; do
    2156421622
    2156521623  for proj in $projtoprocess ; do
    21566     # if $proj has been processed already, skip this round
    21567     if test "x$projprocessed" != x ; then
    21568       for projdone in $projprocessed ; do
    21569         if test $projdone = $proj ; then
    21570           continue 2
    21571         fi
    21572       done
    21573     fi
    21574 
    2157521624    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2157621625    pcfile=""
     
    2158121630      if test -r "$dir/$proj-uninstalled.pc" ; then
    2158221631        pcfile="$dir/$proj-uninstalled.pc"
    21583         pcfiledir="$dir"
    2158421632        break
    2158521633      fi
     
    2158821636
    2158921637    if test "x$pcfile" != x ; then
    21590       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    21591       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    21592       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    21593       OSITESTS_CFLAGS="$projcflags $OSITESTS_CFLAGS"
    21594 
    21595       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    21596       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    21597       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    21598       if test "x$projlibs" != x ; then
    21599         if test -d "${pcfiledir}/src" ; then
    21600           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    21601         else
    21602           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    21603         fi
    21604       else
    21605         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    21606       fi
    21607       OSITESTS_LIBS="$OSITESTS_LIBS $projlibs"
     21638      # read dependencies from $pcfile and filter it
     21639      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     21640
     21641      # add projrequires to the front of the list of projects that have to be processed next
     21642      # at the same time, remove $proj from this list
     21643      projtoprocess=${projtoprocess/$proj/$projrequires}
    2160821644
    2160921645      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    21610       if test "x$projprocessed" = x ; then
     21646      if test "x$allproj" = x ; then
    2161121647        OSITESTS_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2161221648      fi
    2161321649
    21614       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    21615       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    21616       nextprojtoprocess="$nextprojtoprocess $projrequires"
    21617 
    21618       # remember that we have processed $proj
    21619       projprocessed="$projprocessed $proj"
     21650      allproj="$allproj $proj"
     21651      allpcfiles="$pcfile:$allpcfiles"
    2162021652
    2162121653    else
    2162221654      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2162321655echo "${ECHO_T}no, dependency $proj not available" >&6
     21656      allproj=fail
    2162421657      break 2
    2162521658    fi
    2162621659
     21660    break
    2162721661  done
    2162821662
    21629   projtoprocess="$nextprojtoprocess"
    21630 
    21631   # if there are no more projects to search for, finish up
    21632   if test "x$projtoprocess" = x ; then
    21633     coin_has_ositests=yes
    21634     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    21635 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     21663  # remove spaces on begin of $projtoprocess
     21664  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     21665
     21666done
     21667
     21668if test "$allproj" != fail ; then
     21669
     21670  # now go through the list of .pc files and assemble compiler and linker flags
     21671  # important is here to obey the reverse order that has been setup before,
     21672  # since then libraries that are required by several others should be after these other libraries
     21673  pcfilesprocessed=""
     21674
     21675  save_IFS="$IFS"
     21676  IFS=":"
     21677  for pcfile in $allpcfiles ; do
     21678
     21679    # if $pcfile has been processed already, skip this round
     21680    if test "x$pcfilesprocessed" != x ; then
     21681      for pcfiledone in $pcfilesprocessed ; do
     21682        if test "$pcfiledone" = "$pcfile" ; then
     21683          continue 2
     21684        fi
     21685      done
     21686    fi
     21687
     21688    # reconstruct the directory where the .pc file is located
     21689    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     21690
     21691    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21692    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     21693    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     21694    OSITESTS_CFLAGS="$projcflags $OSITESTS_CFLAGS"
     21695
     21696    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21697    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21698    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21699    if test "x$projlibs" != x ; then
     21700      if test -d "${pcfiledir}/src" ; then
     21701        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21702      else
     21703        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21704      fi
     21705    else
     21706      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     21707    fi
     21708    OSITESTS_LIBS="$projlibs $OSITESTS_LIBS"
     21709
     21710    # remember that we have processed $pcfile
     21711    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     21712
     21713  done
     21714  IFS="$save_IFS"
     21715
     21716  # finish up
     21717  coin_has_ositests=yes
     21718  echo "$as_me:$LINENO: result: yes" >&5
     21719echo "${ECHO_T}yes" >&6
    2163621720
    2163721721cat >>confdefs.h <<\_ACEOF
     
    2164221726
    2164321727
    21644     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    21645       if test -n "$OSITESTS_CFLAGS" ; then
    21646         { echo "$as_me:$LINENO: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&5
     21728  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21729    if test -n "$OSITESTS_CFLAGS" ; then
     21730      { echo "$as_me:$LINENO: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&5
    2164721731echo "$as_me: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&6;}
    21648       fi
    21649       if test -n "$OSITESTS_LIBS" ; then
    21650         { echo "$as_me:$LINENO: OsiTests LIBS   are $OSITESTS_LIBS" >&5
     21732    fi
     21733    if test -n "$OSITESTS_LIBS" ; then
     21734      { echo "$as_me:$LINENO: OsiTests LIBS   are $OSITESTS_LIBS" >&5
    2165121735echo "$as_me: OsiTests LIBS   are $OSITESTS_LIBS" >&6;}
    21652       fi
    21653       if test -n "$OSITESTS_DATA" ; then
    21654         { echo "$as_me:$LINENO: OsiTests DATA   is  $OSITESTS_DATA" >&5
     21736    fi
     21737    if test -n "$OSITESTS_DATA" ; then
     21738      { echo "$as_me:$LINENO: OsiTests DATA   is  $OSITESTS_DATA" >&5
    2165521739echo "$as_me: OsiTests DATA   is  $OSITESTS_DATA" >&6;}
    21656       fi
    21657 
    2165821740    fi
     21741
    2165921742  fi
    21660 done
     21743
     21744fi
    2166121745
    2166221746
     
    2184621930# initial list of dependencies is "coindatasample", but we need to filter out version number specifications (= x, <= x, >= x)
    2184721931projtoprocess="coindatasample"
    21848 projprocessed=""
    21849 
    21850 while test $coin_has_sample = notGiven ; do
    21851   # setup list of projects that need to be processed in the next round
    21852   nextprojtoprocess=""
     21932
     21933# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     21934# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     21935# also, we setup the DATA variable
     21936allproj=""
     21937allpcfiles=""
     21938while test "x$projtoprocess" != x ; do
    2185321939
    2185421940  for proj in $projtoprocess ; do
    21855     # if $proj has been processed already, skip this round
    21856     if test "x$projprocessed" != x ; then
    21857       for projdone in $projprocessed ; do
    21858         if test $projdone = $proj ; then
    21859           continue 2
    21860         fi
    21861       done
    21862     fi
    21863 
    2186421941    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2186521942    pcfile=""
     
    2187021947      if test -r "$dir/$proj-uninstalled.pc" ; then
    2187121948        pcfile="$dir/$proj-uninstalled.pc"
    21872         pcfiledir="$dir"
    2187321949        break
    2187421950      fi
     
    2187721953
    2187821954    if test "x$pcfile" != x ; then
    21879       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    21880       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    21881       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    21882       SAMPLE_CFLAGS="$projcflags $SAMPLE_CFLAGS"
    21883 
    21884       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    21885       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    21886       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    21887       if test "x$projlibs" != x ; then
    21888         if test -d "${pcfiledir}/src" ; then
    21889           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    21890         else
    21891           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    21892         fi
    21893       else
    21894         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    21895       fi
    21896       SAMPLE_LIBS="$SAMPLE_LIBS $projlibs"
     21955      # read dependencies from $pcfile and filter it
     21956      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     21957
     21958      # add projrequires to the front of the list of projects that have to be processed next
     21959      # at the same time, remove $proj from this list
     21960      projtoprocess=${projtoprocess/$proj/$projrequires}
    2189721961
    2189821962      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    21899       if test "x$projprocessed" = x ; then
     21963      if test "x$allproj" = x ; then
    2190021964        SAMPLE_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2190121965      fi
    2190221966
    21903       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    21904       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    21905       nextprojtoprocess="$nextprojtoprocess $projrequires"
    21906 
    21907       # remember that we have processed $proj
    21908       projprocessed="$projprocessed $proj"
     21967      allproj="$allproj $proj"
     21968      allpcfiles="$pcfile:$allpcfiles"
    2190921969
    2191021970    else
    2191121971      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2191221972echo "${ECHO_T}no, dependency $proj not available" >&6
     21973      allproj=fail
    2191321974      break 2
    2191421975    fi
    2191521976
     21977    break
    2191621978  done
    2191721979
    21918   projtoprocess="$nextprojtoprocess"
    21919 
    21920   # if there are no more projects to search for, finish up
    21921   if test "x$projtoprocess" = x ; then
    21922     coin_has_sample=yes
    21923     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    21924 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     21980  # remove spaces on begin of $projtoprocess
     21981  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     21982
     21983done
     21984
     21985if test "$allproj" != fail ; then
     21986
     21987  # now go through the list of .pc files and assemble compiler and linker flags
     21988  # important is here to obey the reverse order that has been setup before,
     21989  # since then libraries that are required by several others should be after these other libraries
     21990  pcfilesprocessed=""
     21991
     21992  save_IFS="$IFS"
     21993  IFS=":"
     21994  for pcfile in $allpcfiles ; do
     21995
     21996    # if $pcfile has been processed already, skip this round
     21997    if test "x$pcfilesprocessed" != x ; then
     21998      for pcfiledone in $pcfilesprocessed ; do
     21999        if test "$pcfiledone" = "$pcfile" ; then
     22000          continue 2
     22001        fi
     22002      done
     22003    fi
     22004
     22005    # reconstruct the directory where the .pc file is located
     22006    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     22007
     22008    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     22009    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     22010    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     22011    SAMPLE_CFLAGS="$projcflags $SAMPLE_CFLAGS"
     22012
     22013    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     22014    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     22015    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     22016    if test "x$projlibs" != x ; then
     22017      if test -d "${pcfiledir}/src" ; then
     22018        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     22019      else
     22020        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     22021      fi
     22022    else
     22023      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     22024    fi
     22025    SAMPLE_LIBS="$projlibs $SAMPLE_LIBS"
     22026
     22027    # remember that we have processed $pcfile
     22028    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     22029
     22030  done
     22031  IFS="$save_IFS"
     22032
     22033  # finish up
     22034  coin_has_sample=yes
     22035  echo "$as_me:$LINENO: result: yes" >&5
     22036echo "${ECHO_T}yes" >&6
    2192522037
    2192622038cat >>confdefs.h <<\_ACEOF
     
    2193122043
    2193222044
    21933     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    21934       if test -n "$SAMPLE_CFLAGS" ; then
    21935         { echo "$as_me:$LINENO: Sample CFLAGS are $SAMPLE_CFLAGS" >&5
     22045  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     22046    if test -n "$SAMPLE_CFLAGS" ; then
     22047      { echo "$as_me:$LINENO: Sample CFLAGS are $SAMPLE_CFLAGS" >&5
    2193622048echo "$as_me: Sample CFLAGS are $SAMPLE_CFLAGS" >&6;}
    21937       fi
    21938       if test -n "$SAMPLE_LIBS" ; then
    21939         { echo "$as_me:$LINENO: Sample LIBS   are $SAMPLE_LIBS" >&5
     22049    fi
     22050    if test -n "$SAMPLE_LIBS" ; then
     22051      { echo "$as_me:$LINENO: Sample LIBS   are $SAMPLE_LIBS" >&5
    2194022052echo "$as_me: Sample LIBS   are $SAMPLE_LIBS" >&6;}
    21941       fi
    21942       if test -n "$SAMPLE_DATA" ; then
    21943         { echo "$as_me:$LINENO: Sample DATA   is  $SAMPLE_DATA" >&5
     22053    fi
     22054    if test -n "$SAMPLE_DATA" ; then
     22055      { echo "$as_me:$LINENO: Sample DATA   is  $SAMPLE_DATA" >&5
    2194422056echo "$as_me: Sample DATA   is  $SAMPLE_DATA" >&6;}
    21945       fi
    21946 
    2194722057    fi
     22058
    2194822059  fi
    21949 done
     22060
     22061fi
    2195022062
    2195122063
     
    2213522247# initial list of dependencies is "coindatanetlib", but we need to filter out version number specifications (= x, <= x, >= x)
    2213622248projtoprocess="coindatanetlib"
    22137 projprocessed=""
    22138 
    22139 while test $coin_has_netlib = notGiven ; do
    22140   # setup list of projects that need to be processed in the next round
    22141   nextprojtoprocess=""
     22249
     22250# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     22251# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     22252# also, we setup the DATA variable
     22253allproj=""
     22254allpcfiles=""
     22255while test "x$projtoprocess" != x ; do
    2214222256
    2214322257  for proj in $projtoprocess ; do
    22144     # if $proj has been processed already, skip this round
    22145     if test "x$projprocessed" != x ; then
    22146       for projdone in $projprocessed ; do
    22147         if test $projdone = $proj ; then
    22148           continue 2
    22149         fi
    22150       done
    22151     fi
    22152 
    2215322258    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2215422259    pcfile=""
     
    2215922264      if test -r "$dir/$proj-uninstalled.pc" ; then
    2216022265        pcfile="$dir/$proj-uninstalled.pc"
    22161         pcfiledir="$dir"
    2216222266        break
    2216322267      fi
     
    2216622270
    2216722271    if test "x$pcfile" != x ; then
    22168       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    22169       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    22170       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    22171       NETLIB_CFLAGS="$projcflags $NETLIB_CFLAGS"
    22172 
    22173       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    22174       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    22175       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    22176       if test "x$projlibs" != x ; then
    22177         if test -d "${pcfiledir}/src" ; then
    22178           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    22179         else
    22180           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    22181         fi
    22182       else
    22183         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    22184       fi
    22185       NETLIB_LIBS="$NETLIB_LIBS $projlibs"
     22272      # read dependencies from $pcfile and filter it
     22273      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     22274
     22275      # add projrequires to the front of the list of projects that have to be processed next
     22276      # at the same time, remove $proj from this list
     22277      projtoprocess=${projtoprocess/$proj/$projrequires}
    2218622278
    2218722279      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    22188       if test "x$projprocessed" = x ; then
     22280      if test "x$allproj" = x ; then
    2218922281        NETLIB_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2219022282      fi
    2219122283
    22192       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    22193       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    22194       nextprojtoprocess="$nextprojtoprocess $projrequires"
    22195 
    22196       # remember that we have processed $proj
    22197       projprocessed="$projprocessed $proj"
     22284      allproj="$allproj $proj"
     22285      allpcfiles="$pcfile:$allpcfiles"
    2219822286
    2219922287    else
    2220022288      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2220122289echo "${ECHO_T}no, dependency $proj not available" >&6
     22290      allproj=fail
    2220222291      break 2
    2220322292    fi
    2220422293
     22294    break
    2220522295  done
    2220622296
    22207   projtoprocess="$nextprojtoprocess"
    22208 
    22209   # if there are no more projects to search for, finish up
    22210   if test "x$projtoprocess" = x ; then
    22211     coin_has_netlib=yes
    22212     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    22213 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     22297  # remove spaces on begin of $projtoprocess
     22298  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     22299
     22300done
     22301
     22302if test "$allproj" != fail ; then
     22303
     22304  # now go through the list of .pc files and assemble compiler and linker flags
     22305  # important is here to obey the reverse order that has been setup before,
     22306  # since then libraries that are required by several others should be after these other libraries
     22307  pcfilesprocessed=""
     22308
     22309  save_IFS="$IFS"
     22310  IFS=":"
     22311  for pcfile in $allpcfiles ; do
     22312
     22313    # if $pcfile has been processed already, skip this round
     22314    if test "x$pcfilesprocessed" != x ; then
     22315      for pcfiledone in $pcfilesprocessed ; do
     22316        if test "$pcfiledone" = "$pcfile" ; then
     22317          continue 2
     22318        fi
     22319      done
     22320    fi
     22321
     22322    # reconstruct the directory where the .pc file is located
     22323    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     22324
     22325    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     22326    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     22327    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     22328    NETLIB_CFLAGS="$projcflags $NETLIB_CFLAGS"
     22329
     22330    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     22331    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     22332    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     22333    if test "x$projlibs" != x ; then
     22334      if test -d "${pcfiledir}/src" ; then
     22335        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     22336      else
     22337        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     22338      fi
     22339    else
     22340      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     22341    fi
     22342    NETLIB_LIBS="$projlibs $NETLIB_LIBS"
     22343
     22344    # remember that we have processed $pcfile
     22345    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     22346
     22347  done
     22348  IFS="$save_IFS"
     22349
     22350  # finish up
     22351  coin_has_netlib=yes
     22352  echo "$as_me:$LINENO: result: yes" >&5
     22353echo "${ECHO_T}yes" >&6
    2221422354
    2221522355cat >>confdefs.h <<\_ACEOF
     
    2222022360
    2222122361
    22222     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    22223       if test -n "$NETLIB_CFLAGS" ; then
    22224         { echo "$as_me:$LINENO: Netlib CFLAGS are $NETLIB_CFLAGS" >&5
     22362  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     22363    if test -n "$NETLIB_CFLAGS" ; then
     22364      { echo "$as_me:$LINENO: Netlib CFLAGS are $NETLIB_CFLAGS" >&5
    2222522365echo "$as_me: Netlib CFLAGS are $NETLIB_CFLAGS" >&6;}
    22226       fi
    22227       if test -n "$NETLIB_LIBS" ; then
    22228         { echo "$as_me:$LINENO: Netlib LIBS   are $NETLIB_LIBS" >&5
     22366    fi
     22367    if test -n "$NETLIB_LIBS" ; then
     22368      { echo "$as_me:$LINENO: Netlib LIBS   are $NETLIB_LIBS" >&5
    2222922369echo "$as_me: Netlib LIBS   are $NETLIB_LIBS" >&6;}
    22230       fi
    22231       if test -n "$NETLIB_DATA" ; then
    22232         { echo "$as_me:$LINENO: Netlib DATA   is  $NETLIB_DATA" >&5
     22370    fi
     22371    if test -n "$NETLIB_DATA" ; then
     22372      { echo "$as_me:$LINENO: Netlib DATA   is  $NETLIB_DATA" >&5
    2223322373echo "$as_me: Netlib DATA   is  $NETLIB_DATA" >&6;}
    22234       fi
    22235 
    2223622374    fi
     22375
    2223722376  fi
    22238 done
     22377
     22378fi
    2223922379
    2224022380
     
    2242422564# initial list of dependencies is "coindatamiplib3", but we need to filter out version number specifications (= x, <= x, >= x)
    2242522565projtoprocess="coindatamiplib3"
    22426 projprocessed=""
    22427 
    22428 while test $coin_has_miplib3 = notGiven ; do
    22429   # setup list of projects that need to be processed in the next round
    22430   nextprojtoprocess=""
     22566
     22567# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     22568# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     22569# also, we setup the DATA variable
     22570allproj=""
     22571allpcfiles=""
     22572while test "x$projtoprocess" != x ; do
    2243122573
    2243222574  for proj in $projtoprocess ; do
    22433     # if $proj has been processed already, skip this round
    22434     if test "x$projprocessed" != x ; then
    22435       for projdone in $projprocessed ; do
    22436         if test $projdone = $proj ; then
    22437           continue 2
    22438         fi
    22439       done
    22440     fi
    22441 
    2244222575    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2244322576    pcfile=""
     
    2244822581      if test -r "$dir/$proj-uninstalled.pc" ; then
    2244922582        pcfile="$dir/$proj-uninstalled.pc"
    22450         pcfiledir="$dir"
    2245122583        break
    2245222584      fi
     
    2245522587
    2245622588    if test "x$pcfile" != x ; then
    22457       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    22458       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    22459       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    22460       MIPLIB3_CFLAGS="$projcflags $MIPLIB3_CFLAGS"
    22461 
    22462       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    22463       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    22464       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    22465       if test "x$projlibs" != x ; then
    22466         if test -d "${pcfiledir}/src" ; then
    22467           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    22468         else
    22469           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    22470         fi
    22471       else
    22472         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    22473       fi
    22474       MIPLIB3_LIBS="$MIPLIB3_LIBS $projlibs"
     22589      # read dependencies from $pcfile and filter it
     22590      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     22591
     22592      # add projrequires to the front of the list of projects that have to be processed next
     22593      # at the same time, remove $proj from this list
     22594      projtoprocess=${projtoprocess/$proj/$projrequires}
    2247522595
    2247622596      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    22477       if test "x$projprocessed" = x ; then
     22597      if test "x$allproj" = x ; then
    2247822598        MIPLIB3_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2247922599      fi
    2248022600
    22481       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    22482       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    22483       nextprojtoprocess="$nextprojtoprocess $projrequires"
    22484 
    22485       # remember that we have processed $proj
    22486       projprocessed="$projprocessed $proj"
     22601      allproj="$allproj $proj"
     22602      allpcfiles="$pcfile:$allpcfiles"
    2248722603
    2248822604    else
    2248922605      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2249022606echo "${ECHO_T}no, dependency $proj not available" >&6
     22607      allproj=fail
    2249122608      break 2
    2249222609    fi
    2249322610
     22611    break
    2249422612  done
    2249522613
    22496   projtoprocess="$nextprojtoprocess"
    22497 
    22498   # if there are no more projects to search for, finish up
    22499   if test "x$projtoprocess" = x ; then
    22500     coin_has_miplib3=yes
    22501     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    22502 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     22614  # remove spaces on begin of $projtoprocess
     22615  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     22616
     22617done
     22618
     22619if test "$allproj" != fail ; then
     22620
     22621  # now go through the list of .pc files and assemble compiler and linker flags
     22622  # important is here to obey the reverse order that has been setup before,
     22623  # since then libraries that are required by several others should be after these other libraries
     22624  pcfilesprocessed=""
     22625
     22626  save_IFS="$IFS"
     22627  IFS=":"
     22628  for pcfile in $allpcfiles ; do
     22629
     22630    # if $pcfile has been processed already, skip this round
     22631    if test "x$pcfilesprocessed" != x ; then
     22632      for pcfiledone in $pcfilesprocessed ; do
     22633        if test "$pcfiledone" = "$pcfile" ; then
     22634          continue 2
     22635        fi
     22636      done
     22637    fi
     22638
     22639    # reconstruct the directory where the .pc file is located
     22640    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     22641
     22642    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     22643    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     22644    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     22645    MIPLIB3_CFLAGS="$projcflags $MIPLIB3_CFLAGS"
     22646
     22647    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     22648    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     22649    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     22650    if test "x$projlibs" != x ; then
     22651      if test -d "${pcfiledir}/src" ; then
     22652        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     22653      else
     22654        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     22655      fi
     22656    else
     22657      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     22658    fi
     22659    MIPLIB3_LIBS="$projlibs $MIPLIB3_LIBS"
     22660
     22661    # remember that we have processed $pcfile
     22662    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     22663
     22664  done
     22665  IFS="$save_IFS"
     22666
     22667  # finish up
     22668  coin_has_miplib3=yes
     22669  echo "$as_me:$LINENO: result: yes" >&5
     22670echo "${ECHO_T}yes" >&6
    2250322671
    2250422672cat >>confdefs.h <<\_ACEOF
     
    2250922677
    2251022678
    22511     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    22512       if test -n "$MIPLIB3_CFLAGS" ; then
    22513         { echo "$as_me:$LINENO: Miplib3 CFLAGS are $MIPLIB3_CFLAGS" >&5
     22679  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     22680    if test -n "$MIPLIB3_CFLAGS" ; then
     22681      { echo "$as_me:$LINENO: Miplib3 CFLAGS are $MIPLIB3_CFLAGS" >&5
    2251422682echo "$as_me: Miplib3 CFLAGS are $MIPLIB3_CFLAGS" >&6;}
    22515       fi
    22516       if test -n "$MIPLIB3_LIBS" ; then
    22517         { echo "$as_me:$LINENO: Miplib3 LIBS   are $MIPLIB3_LIBS" >&5
     22683    fi
     22684    if test -n "$MIPLIB3_LIBS" ; then
     22685      { echo "$as_me:$LINENO: Miplib3 LIBS   are $MIPLIB3_LIBS" >&5
    2251822686echo "$as_me: Miplib3 LIBS   are $MIPLIB3_LIBS" >&6;}
    22519       fi
    22520       if test -n "$MIPLIB3_DATA" ; then
    22521         { echo "$as_me:$LINENO: Miplib3 DATA   is  $MIPLIB3_DATA" >&5
     22687    fi
     22688    if test -n "$MIPLIB3_DATA" ; then
     22689      { echo "$as_me:$LINENO: Miplib3 DATA   is  $MIPLIB3_DATA" >&5
    2252222690echo "$as_me: Miplib3 DATA   is  $MIPLIB3_DATA" >&6;}
    22523       fi
    22524 
    2252522691    fi
     22692
    2252622693  fi
    22527 done
     22694
     22695fi
    2252822696
    2252922697
     
    2273222900# initial list of dependencies is "osi-dylp", but we need to filter out version number specifications (= x, <= x, >= x)
    2273322901projtoprocess="osi-dylp"
    22734 projprocessed=""
    22735 
    22736 while test $coin_has_dylp = notGiven ; do
    22737   # setup list of projects that need to be processed in the next round
    22738   nextprojtoprocess=""
     22902
     22903# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     22904# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     22905# also, we setup the DATA variable
     22906allproj=""
     22907allpcfiles=""
     22908while test "x$projtoprocess" != x ; do
    2273922909
    2274022910  for proj in $projtoprocess ; do
    22741     # if $proj has been processed already, skip this round
    22742     if test "x$projprocessed" != x ; then
    22743       for projdone in $projprocessed ; do
    22744         if test $projdone = $proj ; then
    22745           continue 2
    22746         fi
    22747       done
    22748     fi
    22749 
    2275022911    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2275122912    pcfile=""
     
    2275622917      if test -r "$dir/$proj-uninstalled.pc" ; then
    2275722918        pcfile="$dir/$proj-uninstalled.pc"
    22758         pcfiledir="$dir"
    2275922919        break
    2276022920      fi
     
    2276322923
    2276422924    if test "x$pcfile" != x ; then
    22765       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    22766       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    22767       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    22768       DYLP_CFLAGS="$projcflags $DYLP_CFLAGS"
    22769 
    22770       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    22771       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    22772       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    22773       if test "x$projlibs" != x ; then
    22774         if test -d "${pcfiledir}/src" ; then
    22775           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    22776         else
    22777           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    22778         fi
    22779       else
    22780         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    22781       fi
    22782       DYLP_LIBS="$DYLP_LIBS $projlibs"
     22925      # read dependencies from $pcfile and filter it
     22926      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     22927
     22928      # add projrequires to the front of the list of projects that have to be processed next
     22929      # at the same time, remove $proj from this list
     22930      projtoprocess=${projtoprocess/$proj/$projrequires}
    2278322931
    2278422932      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    22785       if test "x$projprocessed" = x ; then
     22933      if test "x$allproj" = x ; then
    2278622934        DYLP_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2278722935      fi
    2278822936
    22789       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    22790       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    22791       nextprojtoprocess="$nextprojtoprocess $projrequires"
    22792 
    22793       # remember that we have processed $proj
    22794       projprocessed="$projprocessed $proj"
     22937      allproj="$allproj $proj"
     22938      allpcfiles="$pcfile:$allpcfiles"
    2279522939
    2279622940    else
    2279722941      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2279822942echo "${ECHO_T}no, dependency $proj not available" >&6
     22943      allproj=fail
    2279922944      break 2
    2280022945    fi
    2280122946
     22947    break
    2280222948  done
    2280322949
    22804   projtoprocess="$nextprojtoprocess"
    22805 
    22806   # if there are no more projects to search for, finish up
    22807   if test "x$projtoprocess" = x ; then
    22808     coin_has_dylp=yes
    22809     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    22810 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     22950  # remove spaces on begin of $projtoprocess
     22951  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     22952
     22953done
     22954
     22955if test "$allproj" != fail ; then
     22956
     22957  # now go through the list of .pc files and assemble compiler and linker flags
     22958  # important is here to obey the reverse order that has been setup before,
     22959  # since then libraries that are required by several others should be after these other libraries
     22960  pcfilesprocessed=""
     22961
     22962  save_IFS="$IFS"
     22963  IFS=":"
     22964  for pcfile in $allpcfiles ; do
     22965
     22966    # if $pcfile has been processed already, skip this round
     22967    if test "x$pcfilesprocessed" != x ; then
     22968      for pcfiledone in $pcfilesprocessed ; do
     22969        if test "$pcfiledone" = "$pcfile" ; then
     22970          continue 2
     22971        fi
     22972      done
     22973    fi
     22974
     22975    # reconstruct the directory where the .pc file is located
     22976    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     22977
     22978    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     22979    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     22980    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     22981    DYLP_CFLAGS="$projcflags $DYLP_CFLAGS"
     22982
     22983    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     22984    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     22985    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     22986    if test "x$projlibs" != x ; then
     22987      if test -d "${pcfiledir}/src" ; then
     22988        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     22989      else
     22990        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     22991      fi
     22992    else
     22993      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     22994    fi
     22995    DYLP_LIBS="$projlibs $DYLP_LIBS"
     22996
     22997    # remember that we have processed $pcfile
     22998    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     22999
     23000  done
     23001  IFS="$save_IFS"
     23002
     23003  # finish up
     23004  coin_has_dylp=yes
     23005  echo "$as_me:$LINENO: result: yes" >&5
     23006echo "${ECHO_T}yes" >&6
    2281123007
    2281223008cat >>confdefs.h <<\_ACEOF
     
    2281623012
    2281723013
    22818       CBCGENERIC_PCREQUIRES="osi-dylp $CBCGENERIC_PCREQUIRES"
    22819       CBCGENERIC_CFLAGS="$DYLP_CFLAGS $CBCGENERIC_CFLAGS"
    22820       CBCGENERIC_LIBS="$DYLP_LIBS $CBCGENERIC_LIBS"
    22821 
    22822 
    22823     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    22824       if test -n "$DYLP_CFLAGS" ; then
    22825         { echo "$as_me:$LINENO: DyLP CFLAGS are $DYLP_CFLAGS" >&5
     23014    CBCGENERIC_PCREQUIRES="osi-dylp $CBCGENERIC_PCREQUIRES"
     23015    CBCGENERIC_CFLAGS="$DYLP_CFLAGS $CBCGENERIC_CFLAGS"
     23016    CBCGENERIC_LIBS="$DYLP_LIBS $CBCGENERIC_LIBS"
     23017
     23018
     23019  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     23020    if test -n "$DYLP_CFLAGS" ; then
     23021      { echo "$as_me:$LINENO: DyLP CFLAGS are $DYLP_CFLAGS" >&5
    2282623022echo "$as_me: DyLP CFLAGS are $DYLP_CFLAGS" >&6;}
    22827       fi
    22828       if test -n "$DYLP_LIBS" ; then
    22829         { echo "$as_me:$LINENO: DyLP LIBS   are $DYLP_LIBS" >&5
     23023    fi
     23024    if test -n "$DYLP_LIBS" ; then
     23025      { echo "$as_me:$LINENO: DyLP LIBS   are $DYLP_LIBS" >&5
    2283023026echo "$as_me: DyLP LIBS   are $DYLP_LIBS" >&6;}
    22831       fi
    22832       if test -n "$DYLP_DATA" ; then
    22833         { echo "$as_me:$LINENO: DyLP DATA   is  $DYLP_DATA" >&5
     23027    fi
     23028    if test -n "$DYLP_DATA" ; then
     23029      { echo "$as_me:$LINENO: DyLP DATA   is  $DYLP_DATA" >&5
    2283423030echo "$as_me: DyLP DATA   is  $DYLP_DATA" >&6;}
    22835       fi
    22836 
    22837         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     23031    fi
     23032
     23033      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2283823034echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    22839         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     23035      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2284023036echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2284123037
    22842     fi
    2284323038  fi
    22844 done
     23039
     23040fi
    2284523041
    2284623042
     
    2303523231# initial list of dependencies is "osi-vol", but we need to filter out version number specifications (= x, <= x, >= x)
    2303623232projtoprocess="osi-vol"
    23037 projprocessed=""
    23038 
    23039 while test $coin_has_vol = notGiven ; do
    23040   # setup list of projects that need to be processed in the next round
    23041   nextprojtoprocess=""
     23233
     23234# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     23235# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     23236# also, we setup the DATA variable
     23237allproj=""
     23238allpcfiles=""
     23239while test "x$projtoprocess" != x ; do
    2304223240
    2304323241  for proj in $projtoprocess ; do
    23044     # if $proj has been processed already, skip this round
    23045     if test "x$projprocessed" != x ; then
    23046       for projdone in $projprocessed ; do
    23047         if test $projdone = $proj ; then
    23048           continue 2
    23049         fi
    23050       done
    23051     fi
    23052 
    2305323242    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2305423243    pcfile=""
     
    2305923248      if test -r "$dir/$proj-uninstalled.pc" ; then
    2306023249        pcfile="$dir/$proj-uninstalled.pc"
    23061         pcfiledir="$dir"
    2306223250        break
    2306323251      fi
     
    2306623254
    2306723255    if test "x$pcfile" != x ; then
    23068       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    23069       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    23070       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    23071       VOL_CFLAGS="$projcflags $VOL_CFLAGS"
    23072 
    23073       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    23074       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    23075       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    23076       if test "x$projlibs" != x ; then
    23077         if test -d "${pcfiledir}/src" ; then
    23078           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    23079         else
    23080           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    23081         fi
    23082       else
    23083         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    23084       fi
    23085       VOL_LIBS="$VOL_LIBS $projlibs"
     23256      # read dependencies from $pcfile and filter it
     23257      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     23258
     23259      # add projrequires to the front of the list of projects that have to be processed next
     23260      # at the same time, remove $proj from this list
     23261      projtoprocess=${projtoprocess/$proj/$projrequires}
    2308623262
    2308723263      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    23088       if test "x$projprocessed" = x ; then
     23264      if test "x$allproj" = x ; then
    2308923265        VOL_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2309023266      fi
    2309123267
    23092       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    23093       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    23094       nextprojtoprocess="$nextprojtoprocess $projrequires"
    23095 
    23096       # remember that we have processed $proj
    23097       projprocessed="$projprocessed $proj"
     23268      allproj="$allproj $proj"
     23269      allpcfiles="$pcfile:$allpcfiles"
    2309823270
    2309923271    else
    2310023272      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2310123273echo "${ECHO_T}no, dependency $proj not available" >&6
     23274      allproj=fail
    2310223275      break 2
    2310323276    fi
    2310423277
     23278    break
    2310523279  done
    2310623280
    23107   projtoprocess="$nextprojtoprocess"
    23108 
    23109   # if there are no more projects to search for, finish up
    23110   if test "x$projtoprocess" = x ; then
    23111     coin_has_vol=yes
    23112     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    23113 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     23281  # remove spaces on begin of $projtoprocess
     23282  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     23283
     23284done
     23285
     23286if test "$allproj" != fail ; then
     23287
     23288  # now go through the list of .pc files and assemble compiler and linker flags
     23289  # important is here to obey the reverse order that has been setup before,
     23290  # since then libraries that are required by several others should be after these other libraries
     23291  pcfilesprocessed=""
     23292
     23293  save_IFS="$IFS"
     23294  IFS=":"
     23295  for pcfile in $allpcfiles ; do
     23296
     23297    # if $pcfile has been processed already, skip this round
     23298    if test "x$pcfilesprocessed" != x ; then
     23299      for pcfiledone in $pcfilesprocessed ; do
     23300        if test "$pcfiledone" = "$pcfile" ; then
     23301          continue 2
     23302        fi
     23303      done
     23304    fi
     23305
     23306    # reconstruct the directory where the .pc file is located
     23307    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     23308
     23309    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     23310    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     23311    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     23312    VOL_CFLAGS="$projcflags $VOL_CFLAGS"
     23313
     23314    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     23315    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     23316    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     23317    if test "x$projlibs" != x ; then
     23318      if test -d "${pcfiledir}/src" ; then
     23319        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     23320      else
     23321        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     23322      fi
     23323    else
     23324      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     23325    fi
     23326    VOL_LIBS="$projlibs $VOL_LIBS"
     23327
     23328    # remember that we have processed $pcfile
     23329    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     23330
     23331  done
     23332  IFS="$save_IFS"
     23333
     23334  # finish up
     23335  coin_has_vol=yes
     23336  echo "$as_me:$LINENO: result: yes" >&5
     23337echo "${ECHO_T}yes" >&6
    2311423338
    2311523339cat >>confdefs.h <<\_ACEOF
     
    2312023344
    2312123345
    23122     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    23123       if test -n "$VOL_CFLAGS" ; then
    23124         { echo "$as_me:$LINENO: Vol CFLAGS are $VOL_CFLAGS" >&5
     23346  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     23347    if test -n "$VOL_CFLAGS" ; then
     23348      { echo "$as_me:$LINENO: Vol CFLAGS are $VOL_CFLAGS" >&5
    2312523349echo "$as_me: Vol CFLAGS are $VOL_CFLAGS" >&6;}
    23126       fi
    23127       if test -n "$VOL_LIBS" ; then
    23128         { echo "$as_me:$LINENO: Vol LIBS   are $VOL_LIBS" >&5
     23350    fi
     23351    if test -n "$VOL_LIBS" ; then
     23352      { echo "$as_me:$LINENO: Vol LIBS   are $VOL_LIBS" >&5
    2312923353echo "$as_me: Vol LIBS   are $VOL_LIBS" >&6;}
    23130       fi
    23131       if test -n "$VOL_DATA" ; then
    23132         { echo "$as_me:$LINENO: Vol DATA   is  $VOL_DATA" >&5
     23354    fi
     23355    if test -n "$VOL_DATA" ; then
     23356      { echo "$as_me:$LINENO: Vol DATA   is  $VOL_DATA" >&5
    2313323357echo "$as_me: Vol DATA   is  $VOL_DATA" >&6;}
    23134       fi
    23135 
    2313623358    fi
     23359
    2313723360  fi
    23138 done
     23361
     23362fi
    2313923363
    2314023364
     
    2335023574# initial list of dependencies is "osi-cplex", but we need to filter out version number specifications (= x, <= x, >= x)
    2335123575projtoprocess="osi-cplex"
    23352 projprocessed=""
    23353 
    23354 while test $coin_has_cpx = notGiven ; do
    23355   # setup list of projects that need to be processed in the next round
    23356   nextprojtoprocess=""
     23576
     23577# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     23578# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     23579# also, we setup the DATA variable
     23580allproj=""
     23581allpcfiles=""
     23582while test "x$projtoprocess" != x ; do
    2335723583
    2335823584  for proj in $projtoprocess ; do
    23359     # if $proj has been processed already, skip this round
    23360     if test "x$projprocessed" != x ; then
    23361       for projdone in $projprocessed ; do
    23362         if test $projdone = $proj ; then
    23363           continue 2
    23364         fi
    23365       done
    23366     fi
    23367 
    2336823585    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2336923586    pcfile=""
     
    2337423591      if test -r "$dir/$proj-uninstalled.pc" ; then
    2337523592        pcfile="$dir/$proj-uninstalled.pc"
    23376         pcfiledir="$dir"
    2337723593        break
    2337823594      fi
     
    2338123597
    2338223598    if test "x$pcfile" != x ; then
    23383       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    23384       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    23385       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    23386       CPX_CFLAGS="$projcflags $CPX_CFLAGS"
    23387 
    23388       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    23389       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    23390       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    23391       if test "x$projlibs" != x ; then
    23392         if test -d "${pcfiledir}/src" ; then
    23393           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    23394         else
    23395           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    23396         fi
    23397       else
    23398         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    23399       fi
    23400       CPX_LIBS="$CPX_LIBS $projlibs"
     23599      # read dependencies from $pcfile and filter it
     23600      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     23601
     23602      # add projrequires to the front of the list of projects that have to be processed next
     23603      # at the same time, remove $proj from this list
     23604      projtoprocess=${projtoprocess/$proj/$projrequires}
    2340123605
    2340223606      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    23403       if test "x$projprocessed" = x ; then
     23607      if test "x$allproj" = x ; then
    2340423608        CPX_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2340523609      fi
    2340623610
    23407       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    23408       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    23409       nextprojtoprocess="$nextprojtoprocess $projrequires"
    23410 
    23411       # remember that we have processed $proj
    23412       projprocessed="$projprocessed $proj"
     23611      allproj="$allproj $proj"
     23612      allpcfiles="$pcfile:$allpcfiles"
    2341323613
    2341423614    else
    2341523615      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2341623616echo "${ECHO_T}no, dependency $proj not available" >&6
     23617      allproj=fail
    2341723618      break 2
    2341823619    fi
    2341923620
     23621    break
    2342023622  done
    2342123623
    23422   projtoprocess="$nextprojtoprocess"
    23423 
    23424   # if there are no more projects to search for, finish up
    23425   if test "x$projtoprocess" = x ; then
    23426     coin_has_cpx=yes
    23427     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    23428 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     23624  # remove spaces on begin of $projtoprocess
     23625  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     23626
     23627done
     23628
     23629if test "$allproj" != fail ; then
     23630
     23631  # now go through the list of .pc files and assemble compiler and linker flags
     23632  # important is here to obey the reverse order that has been setup before,
     23633  # since then libraries that are required by several others should be after these other libraries
     23634  pcfilesprocessed=""
     23635
     23636  save_IFS="$IFS"
     23637  IFS=":"
     23638  for pcfile in $allpcfiles ; do
     23639
     23640    # if $pcfile has been processed already, skip this round
     23641    if test "x$pcfilesprocessed" != x ; then
     23642      for pcfiledone in $pcfilesprocessed ; do
     23643        if test "$pcfiledone" = "$pcfile" ; then
     23644          continue 2
     23645        fi
     23646      done
     23647    fi
     23648
     23649    # reconstruct the directory where the .pc file is located
     23650    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     23651
     23652    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     23653    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     23654    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     23655    CPX_CFLAGS="$projcflags $CPX_CFLAGS"
     23656
     23657    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     23658    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     23659    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     23660    if test "x$projlibs" != x ; then
     23661      if test -d "${pcfiledir}/src" ; then
     23662        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     23663      else
     23664        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     23665      fi
     23666    else
     23667      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     23668    fi
     23669    CPX_LIBS="$projlibs $CPX_LIBS"
     23670
     23671    # remember that we have processed $pcfile
     23672    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     23673
     23674  done
     23675  IFS="$save_IFS"
     23676
     23677  # finish up
     23678  coin_has_cpx=yes
     23679  echo "$as_me:$LINENO: result: yes" >&5
     23680echo "${ECHO_T}yes" >&6
    2342923681
    2343023682cat >>confdefs.h <<\_ACEOF
     
    2343423686
    2343523687
    23436       CBCLIB_PCREQUIRES="osi-cplex $CBCLIB_PCREQUIRES"
    23437       CBCLIB_CFLAGS="$CPX_CFLAGS $CBCLIB_CFLAGS"
    23438       CBCLIB_LIBS="$CPX_LIBS $CBCLIB_LIBS"
    23439 
    23440       CBCGENERIC_PCREQUIRES="osi-cplex $CBCGENERIC_PCREQUIRES"
    23441       CBCGENERIC_CFLAGS="$CPX_CFLAGS $CBCGENERIC_CFLAGS"
    23442       CBCGENERIC_LIBS="$CPX_LIBS $CBCGENERIC_LIBS"
    23443 
    23444 
    23445     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    23446       if test -n "$CPX_CFLAGS" ; then
    23447         { echo "$as_me:$LINENO: Cpx CFLAGS are $CPX_CFLAGS" >&5
     23688    CBCLIB_PCREQUIRES="osi-cplex $CBCLIB_PCREQUIRES"
     23689    CBCLIB_CFLAGS="$CPX_CFLAGS $CBCLIB_CFLAGS"
     23690    CBCLIB_LIBS="$CPX_LIBS $CBCLIB_LIBS"
     23691
     23692    CBCGENERIC_PCREQUIRES="osi-cplex $CBCGENERIC_PCREQUIRES"
     23693    CBCGENERIC_CFLAGS="$CPX_CFLAGS $CBCGENERIC_CFLAGS"
     23694    CBCGENERIC_LIBS="$CPX_LIBS $CBCGENERIC_LIBS"
     23695
     23696
     23697  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     23698    if test -n "$CPX_CFLAGS" ; then
     23699      { echo "$as_me:$LINENO: Cpx CFLAGS are $CPX_CFLAGS" >&5
    2344823700echo "$as_me: Cpx CFLAGS are $CPX_CFLAGS" >&6;}
    23449       fi
    23450       if test -n "$CPX_LIBS" ; then
    23451         { echo "$as_me:$LINENO: Cpx LIBS   are $CPX_LIBS" >&5
     23701    fi
     23702    if test -n "$CPX_LIBS" ; then
     23703      { echo "$as_me:$LINENO: Cpx LIBS   are $CPX_LIBS" >&5
    2345223704echo "$as_me: Cpx LIBS   are $CPX_LIBS" >&6;}
    23453       fi
    23454       if test -n "$CPX_DATA" ; then
    23455         { echo "$as_me:$LINENO: Cpx DATA   is  $CPX_DATA" >&5
     23705    fi
     23706    if test -n "$CPX_DATA" ; then
     23707      { echo "$as_me:$LINENO: Cpx DATA   is  $CPX_DATA" >&5
    2345623708echo "$as_me: Cpx DATA   is  $CPX_DATA" >&6;}
    23457       fi
    23458 
    23459         { echo "$as_me:$LINENO: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&5
     23709    fi
     23710
     23711      { echo "$as_me:$LINENO: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&5
    2346023712echo "$as_me: CbcLib CFLAGS are $CBCLIB_CFLAGS" >&6;}
    23461         { echo "$as_me:$LINENO: CbcLib LIBS   are $CBCLIB_LIBS" >&5
     23713      { echo "$as_me:$LINENO: CbcLib LIBS   are $CBCLIB_LIBS" >&5
    2346223714echo "$as_me: CbcLib LIBS   are $CBCLIB_LIBS" >&6;}
    2346323715
    23464         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     23716      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2346523717echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    23466         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     23718      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2346723719echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2346823720
    23469     fi
    2347023721  fi
    23471 done
     23722
     23723fi
    2347223724
    2347323725
     
    2368023932# initial list of dependencies is "osi-glpk", but we need to filter out version number specifications (= x, <= x, >= x)
    2368123933projtoprocess="osi-glpk"
    23682 projprocessed=""
    23683 
    23684 while test $coin_has_glpk = notGiven ; do
    23685   # setup list of projects that need to be processed in the next round
    23686   nextprojtoprocess=""
     23934
     23935# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     23936# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     23937# also, we setup the DATA variable
     23938allproj=""
     23939allpcfiles=""
     23940while test "x$projtoprocess" != x ; do
    2368723941
    2368823942  for proj in $projtoprocess ; do
    23689     # if $proj has been processed already, skip this round
    23690     if test "x$projprocessed" != x ; then
    23691       for projdone in $projprocessed ; do
    23692         if test $projdone = $proj ; then
    23693           continue 2
    23694         fi
    23695       done
    23696     fi
    23697 
    2369823943    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2369923944    pcfile=""
     
    2370423949      if test -r "$dir/$proj-uninstalled.pc" ; then
    2370523950        pcfile="$dir/$proj-uninstalled.pc"
    23706         pcfiledir="$dir"
    2370723951        break
    2370823952      fi
     
    2371123955
    2371223956    if test "x$pcfile" != x ; then
    23713       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    23714       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    23715       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    23716       GLPK_CFLAGS="$projcflags $GLPK_CFLAGS"
    23717 
    23718       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    23719       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    23720       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    23721       if test "x$projlibs" != x ; then
    23722         if test -d "${pcfiledir}/src" ; then
    23723           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    23724         else
    23725           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    23726         fi
    23727       else
    23728         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    23729       fi
    23730       GLPK_LIBS="$GLPK_LIBS $projlibs"
     23957      # read dependencies from $pcfile and filter it
     23958      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     23959
     23960      # add projrequires to the front of the list of projects that have to be processed next
     23961      # at the same time, remove $proj from this list
     23962      projtoprocess=${projtoprocess/$proj/$projrequires}
    2373123963
    2373223964      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    23733       if test "x$projprocessed" = x ; then
     23965      if test "x$allproj" = x ; then
    2373423966        GLPK_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2373523967      fi
    2373623968
    23737       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    23738       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    23739       nextprojtoprocess="$nextprojtoprocess $projrequires"
    23740 
    23741       # remember that we have processed $proj
    23742       projprocessed="$projprocessed $proj"
     23969      allproj="$allproj $proj"
     23970      allpcfiles="$pcfile:$allpcfiles"
    2374323971
    2374423972    else
    2374523973      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2374623974echo "${ECHO_T}no, dependency $proj not available" >&6
     23975      allproj=fail
    2374723976      break 2
    2374823977    fi
    2374923978
     23979    break
    2375023980  done
    2375123981
    23752   projtoprocess="$nextprojtoprocess"
    23753 
    23754   # if there are no more projects to search for, finish up
    23755   if test "x$projtoprocess" = x ; then
    23756     coin_has_glpk=yes
    23757     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    23758 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     23982  # remove spaces on begin of $projtoprocess
     23983  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     23984
     23985done
     23986
     23987if test "$allproj" != fail ; then
     23988
     23989  # now go through the list of .pc files and assemble compiler and linker flags
     23990  # important is here to obey the reverse order that has been setup before,
     23991  # since then libraries that are required by several others should be after these other libraries
     23992  pcfilesprocessed=""
     23993
     23994  save_IFS="$IFS"
     23995  IFS=":"
     23996  for pcfile in $allpcfiles ; do
     23997
     23998    # if $pcfile has been processed already, skip this round
     23999    if test "x$pcfilesprocessed" != x ; then
     24000      for pcfiledone in $pcfilesprocessed ; do
     24001        if test "$pcfiledone" = "$pcfile" ; then
     24002          continue 2
     24003        fi
     24004      done
     24005    fi
     24006
     24007    # reconstruct the directory where the .pc file is located
     24008    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     24009
     24010    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     24011    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     24012    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     24013    GLPK_CFLAGS="$projcflags $GLPK_CFLAGS"
     24014
     24015    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     24016    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     24017    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     24018    if test "x$projlibs" != x ; then
     24019      if test -d "${pcfiledir}/src" ; then
     24020        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     24021      else
     24022        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     24023      fi
     24024    else
     24025      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     24026    fi
     24027    GLPK_LIBS="$projlibs $GLPK_LIBS"
     24028
     24029    # remember that we have processed $pcfile
     24030    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     24031
     24032  done
     24033  IFS="$save_IFS"
     24034
     24035  # finish up
     24036  coin_has_glpk=yes
     24037  echo "$as_me:$LINENO: result: yes" >&5
     24038echo "${ECHO_T}yes" >&6
    2375924039
    2376024040cat >>confdefs.h <<\_ACEOF
     
    2376424044
    2376524045
    23766       CBCGENERIC_PCREQUIRES="osi-glpk $CBCGENERIC_PCREQUIRES"
    23767       CBCGENERIC_CFLAGS="$GLPK_CFLAGS $CBCGENERIC_CFLAGS"
    23768       CBCGENERIC_LIBS="$GLPK_LIBS $CBCGENERIC_LIBS"
    23769 
    23770 
    23771     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    23772       if test -n "$GLPK_CFLAGS" ; then
    23773         { echo "$as_me:$LINENO: Glpk CFLAGS are $GLPK_CFLAGS" >&5
     24046    CBCGENERIC_PCREQUIRES="osi-glpk $CBCGENERIC_PCREQUIRES"
     24047    CBCGENERIC_CFLAGS="$GLPK_CFLAGS $CBCGENERIC_CFLAGS"
     24048    CBCGENERIC_LIBS="$GLPK_LIBS $CBCGENERIC_LIBS"
     24049
     24050
     24051  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     24052    if test -n "$GLPK_CFLAGS" ; then
     24053      { echo "$as_me:$LINENO: Glpk CFLAGS are $GLPK_CFLAGS" >&5
    2377424054echo "$as_me: Glpk CFLAGS are $GLPK_CFLAGS" >&6;}
    23775       fi
    23776       if test -n "$GLPK_LIBS" ; then
    23777         { echo "$as_me:$LINENO: Glpk LIBS   are $GLPK_LIBS" >&5
     24055    fi
     24056    if test -n "$GLPK_LIBS" ; then
     24057      { echo "$as_me:$LINENO: Glpk LIBS   are $GLPK_LIBS" >&5
    2377824058echo "$as_me: Glpk LIBS   are $GLPK_LIBS" >&6;}
    23779       fi
    23780       if test -n "$GLPK_DATA" ; then
    23781         { echo "$as_me:$LINENO: Glpk DATA   is  $GLPK_DATA" >&5
     24059    fi
     24060    if test -n "$GLPK_DATA" ; then
     24061      { echo "$as_me:$LINENO: Glpk DATA   is  $GLPK_DATA" >&5
    2378224062echo "$as_me: Glpk DATA   is  $GLPK_DATA" >&6;}
    23783       fi
    23784 
    23785         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     24063    fi
     24064
     24065      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2378624066echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    23787         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     24067      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2378824068echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2378924069
    23790     fi
    2379124070  fi
    23792 done
     24071
     24072fi
    2379324073
    2379424074
     
    2398324263# initial list of dependencies is "osi-gurobi", but we need to filter out version number specifications (= x, <= x, >= x)
    2398424264projtoprocess="osi-gurobi"
    23985 projprocessed=""
    23986 
    23987 while test $coin_has_grb = notGiven ; do
    23988   # setup list of projects that need to be processed in the next round
    23989   nextprojtoprocess=""
     24265
     24266# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     24267# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     24268# also, we setup the DATA variable
     24269allproj=""
     24270allpcfiles=""
     24271while test "x$projtoprocess" != x ; do
    2399024272
    2399124273  for proj in $projtoprocess ; do
    23992     # if $proj has been processed already, skip this round
    23993     if test "x$projprocessed" != x ; then
    23994       for projdone in $projprocessed ; do
    23995         if test $projdone = $proj ; then
    23996           continue 2
    23997         fi
    23998       done
    23999     fi
    24000 
    2400124274    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2400224275    pcfile=""
     
    2400724280      if test -r "$dir/$proj-uninstalled.pc" ; then
    2400824281        pcfile="$dir/$proj-uninstalled.pc"
    24009         pcfiledir="$dir"
    2401024282        break
    2401124283      fi
     
    2401424286
    2401524287    if test "x$pcfile" != x ; then
    24016       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    24017       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    24018       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    24019       GRB_CFLAGS="$projcflags $GRB_CFLAGS"
    24020 
    24021       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    24022       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    24023       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    24024       if test "x$projlibs" != x ; then
    24025         if test -d "${pcfiledir}/src" ; then
    24026           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    24027         else
    24028           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    24029         fi
    24030       else
    24031         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    24032       fi
    24033       GRB_LIBS="$GRB_LIBS $projlibs"
     24288      # read dependencies from $pcfile and filter it
     24289      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     24290
     24291      # add projrequires to the front of the list of projects that have to be processed next
     24292      # at the same time, remove $proj from this list
     24293      projtoprocess=${projtoprocess/$proj/$projrequires}
    2403424294
    2403524295      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    24036       if test "x$projprocessed" = x ; then
     24296      if test "x$allproj" = x ; then
    2403724297        GRB_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2403824298      fi
    2403924299
    24040       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    24041       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    24042       nextprojtoprocess="$nextprojtoprocess $projrequires"
    24043 
    24044       # remember that we have processed $proj
    24045       projprocessed="$projprocessed $proj"
     24300      allproj="$allproj $proj"
     24301      allpcfiles="$pcfile:$allpcfiles"
    2404624302
    2404724303    else
    2404824304      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2404924305echo "${ECHO_T}no, dependency $proj not available" >&6
     24306      allproj=fail
    2405024307      break 2
    2405124308    fi
    2405224309
     24310    break
    2405324311  done
    2405424312
    24055   projtoprocess="$nextprojtoprocess"
    24056 
    24057   # if there are no more projects to search for, finish up
    24058   if test "x$projtoprocess" = x ; then
    24059     coin_has_grb=yes
    24060     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    24061 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     24313  # remove spaces on begin of $projtoprocess
     24314  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     24315
     24316done
     24317
     24318if test "$allproj" != fail ; then
     24319
     24320  # now go through the list of .pc files and assemble compiler and linker flags
     24321  # important is here to obey the reverse order that has been setup before,
     24322  # since then libraries that are required by several others should be after these other libraries
     24323  pcfilesprocessed=""
     24324
     24325  save_IFS="$IFS"
     24326  IFS=":"
     24327  for pcfile in $allpcfiles ; do
     24328
     24329    # if $pcfile has been processed already, skip this round
     24330    if test "x$pcfilesprocessed" != x ; then
     24331      for pcfiledone in $pcfilesprocessed ; do
     24332        if test "$pcfiledone" = "$pcfile" ; then
     24333          continue 2
     24334        fi
     24335      done
     24336    fi
     24337
     24338    # reconstruct the directory where the .pc file is located
     24339    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     24340
     24341    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     24342    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     24343    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     24344    GRB_CFLAGS="$projcflags $GRB_CFLAGS"
     24345
     24346    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     24347    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     24348    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     24349    if test "x$projlibs" != x ; then
     24350      if test -d "${pcfiledir}/src" ; then
     24351        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     24352      else
     24353        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     24354      fi
     24355    else
     24356      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     24357    fi
     24358    GRB_LIBS="$projlibs $GRB_LIBS"
     24359
     24360    # remember that we have processed $pcfile
     24361    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     24362
     24363  done
     24364  IFS="$save_IFS"
     24365
     24366  # finish up
     24367  coin_has_grb=yes
     24368  echo "$as_me:$LINENO: result: yes" >&5
     24369echo "${ECHO_T}yes" >&6
    2406224370
    2406324371cat >>confdefs.h <<\_ACEOF
     
    2406824376
    2406924377
    24070     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    24071       if test -n "$GRB_CFLAGS" ; then
    24072         { echo "$as_me:$LINENO: Grb CFLAGS are $GRB_CFLAGS" >&5
     24378  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     24379    if test -n "$GRB_CFLAGS" ; then
     24380      { echo "$as_me:$LINENO: Grb CFLAGS are $GRB_CFLAGS" >&5
    2407324381echo "$as_me: Grb CFLAGS are $GRB_CFLAGS" >&6;}
    24074       fi
    24075       if test -n "$GRB_LIBS" ; then
    24076         { echo "$as_me:$LINENO: Grb LIBS   are $GRB_LIBS" >&5
     24382    fi
     24383    if test -n "$GRB_LIBS" ; then
     24384      { echo "$as_me:$LINENO: Grb LIBS   are $GRB_LIBS" >&5
    2407724385echo "$as_me: Grb LIBS   are $GRB_LIBS" >&6;}
    24078       fi
    24079       if test -n "$GRB_DATA" ; then
    24080         { echo "$as_me:$LINENO: Grb DATA   is  $GRB_DATA" >&5
     24386    fi
     24387    if test -n "$GRB_DATA" ; then
     24388      { echo "$as_me:$LINENO: Grb DATA   is  $GRB_DATA" >&5
    2408124389echo "$as_me: Grb DATA   is  $GRB_DATA" >&6;}
    24082       fi
    24083 
    2408424390    fi
     24391
    2408524392  fi
    24086 done
     24393
     24394fi
    2408724395
    2408824396
     
    2428524593# initial list of dependencies is "osi-mosek", but we need to filter out version number specifications (= x, <= x, >= x)
    2428624594projtoprocess="osi-mosek"
    24287 projprocessed=""
    24288 
    24289 while test $coin_has_msk = notGiven ; do
    24290   # setup list of projects that need to be processed in the next round
    24291   nextprojtoprocess=""
     24595
     24596# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     24597# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     24598# also, we setup the DATA variable
     24599allproj=""
     24600allpcfiles=""
     24601while test "x$projtoprocess" != x ; do
    2429224602
    2429324603  for proj in $projtoprocess ; do
    24294     # if $proj has been processed already, skip this round
    24295     if test "x$projprocessed" != x ; then
    24296       for projdone in $projprocessed ; do
    24297         if test $projdone = $proj ; then
    24298           continue 2
    24299         fi
    24300       done
    24301     fi
    24302 
    2430324604    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2430424605    pcfile=""
     
    2430924610      if test -r "$dir/$proj-uninstalled.pc" ; then
    2431024611        pcfile="$dir/$proj-uninstalled.pc"
    24311         pcfiledir="$dir"
    2431224612        break
    2431324613      fi
     
    2431624616
    2431724617    if test "x$pcfile" != x ; then
    24318       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    24319       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    24320       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    24321       MSK_CFLAGS="$projcflags $MSK_CFLAGS"
    24322 
    24323       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    24324       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    24325       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    24326       if test "x$projlibs" != x ; then
    24327         if test -d "${pcfiledir}/src" ; then
    24328           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    24329         else
    24330           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    24331         fi
    24332       else
    24333         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    24334       fi
    24335       MSK_LIBS="$MSK_LIBS $projlibs"
     24618      # read dependencies from $pcfile and filter it
     24619      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     24620
     24621      # add projrequires to the front of the list of projects that have to be processed next
     24622      # at the same time, remove $proj from this list
     24623      projtoprocess=${projtoprocess/$proj/$projrequires}
    2433624624
    2433724625      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    24338       if test "x$projprocessed" = x ; then
     24626      if test "x$allproj" = x ; then
    2433924627        MSK_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2434024628      fi
    2434124629
    24342       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    24343       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    24344       nextprojtoprocess="$nextprojtoprocess $projrequires"
    24345 
    24346       # remember that we have processed $proj
    24347       projprocessed="$projprocessed $proj"
     24630      allproj="$allproj $proj"
     24631      allpcfiles="$pcfile:$allpcfiles"
    2434824632
    2434924633    else
    2435024634      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2435124635echo "${ECHO_T}no, dependency $proj not available" >&6
     24636      allproj=fail
    2435224637      break 2
    2435324638    fi
    2435424639
     24640    break
    2435524641  done
    2435624642
    24357   projtoprocess="$nextprojtoprocess"
    24358 
    24359   # if there are no more projects to search for, finish up
    24360   if test "x$projtoprocess" = x ; then
    24361     coin_has_msk=yes
    24362     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    24363 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     24643  # remove spaces on begin of $projtoprocess
     24644  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     24645
     24646done
     24647
     24648if test "$allproj" != fail ; then
     24649
     24650  # now go through the list of .pc files and assemble compiler and linker flags
     24651  # important is here to obey the reverse order that has been setup before,
     24652  # since then libraries that are required by several others should be after these other libraries
     24653  pcfilesprocessed=""
     24654
     24655  save_IFS="$IFS"
     24656  IFS=":"
     24657  for pcfile in $allpcfiles ; do
     24658
     24659    # if $pcfile has been processed already, skip this round
     24660    if test "x$pcfilesprocessed" != x ; then
     24661      for pcfiledone in $pcfilesprocessed ; do
     24662        if test "$pcfiledone" = "$pcfile" ; then
     24663          continue 2
     24664        fi
     24665      done
     24666    fi
     24667
     24668    # reconstruct the directory where the .pc file is located
     24669    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     24670
     24671    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     24672    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     24673    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     24674    MSK_CFLAGS="$projcflags $MSK_CFLAGS"
     24675
     24676    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     24677    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     24678    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     24679    if test "x$projlibs" != x ; then
     24680      if test -d "${pcfiledir}/src" ; then
     24681        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     24682      else
     24683        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     24684      fi
     24685    else
     24686      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     24687    fi
     24688    MSK_LIBS="$projlibs $MSK_LIBS"
     24689
     24690    # remember that we have processed $pcfile
     24691    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     24692
     24693  done
     24694  IFS="$save_IFS"
     24695
     24696  # finish up
     24697  coin_has_msk=yes
     24698  echo "$as_me:$LINENO: result: yes" >&5
     24699echo "${ECHO_T}yes" >&6
    2436424700
    2436524701cat >>confdefs.h <<\_ACEOF
     
    2436924705
    2437024706
    24371       CBCGENERIC_PCREQUIRES="osi-mosek $CBCGENERIC_PCREQUIRES"
    24372       CBCGENERIC_CFLAGS="$MSK_CFLAGS $CBCGENERIC_CFLAGS"
    24373       CBCGENERIC_LIBS="$MSK_LIBS $CBCGENERIC_LIBS"
    24374 
    24375 
    24376     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    24377       if test -n "$MSK_CFLAGS" ; then
    24378         { echo "$as_me:$LINENO: Msk CFLAGS are $MSK_CFLAGS" >&5
     24707    CBCGENERIC_PCREQUIRES="osi-mosek $CBCGENERIC_PCREQUIRES"
     24708    CBCGENERIC_CFLAGS="$MSK_CFLAGS $CBCGENERIC_CFLAGS"
     24709    CBCGENERIC_LIBS="$MSK_LIBS $CBCGENERIC_LIBS"
     24710
     24711
     24712  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     24713    if test -n "$MSK_CFLAGS" ; then
     24714      { echo "$as_me:$LINENO: Msk CFLAGS are $MSK_CFLAGS" >&5
    2437924715echo "$as_me: Msk CFLAGS are $MSK_CFLAGS" >&6;}
    24380       fi
    24381       if test -n "$MSK_LIBS" ; then
    24382         { echo "$as_me:$LINENO: Msk LIBS   are $MSK_LIBS" >&5
     24716    fi
     24717    if test -n "$MSK_LIBS" ; then
     24718      { echo "$as_me:$LINENO: Msk LIBS   are $MSK_LIBS" >&5
    2438324719echo "$as_me: Msk LIBS   are $MSK_LIBS" >&6;}
    24384       fi
    24385       if test -n "$MSK_DATA" ; then
    24386         { echo "$as_me:$LINENO: Msk DATA   is  $MSK_DATA" >&5
     24720    fi
     24721    if test -n "$MSK_DATA" ; then
     24722      { echo "$as_me:$LINENO: Msk DATA   is  $MSK_DATA" >&5
    2438724723echo "$as_me: Msk DATA   is  $MSK_DATA" >&6;}
    24388       fi
    24389 
    24390         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     24724    fi
     24725
     24726      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2439124727echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    24392         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     24728      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2439324729echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2439424730
    24395     fi
    2439624731  fi
    24397 done
     24732
     24733fi
    2439824734
    2439924735
     
    2460124937# initial list of dependencies is "osi-soplex", but we need to filter out version number specifications (= x, <= x, >= x)
    2460224938projtoprocess="osi-soplex"
    24603 projprocessed=""
    24604 
    24605 while test $coin_has_spx = notGiven ; do
    24606   # setup list of projects that need to be processed in the next round
    24607   nextprojtoprocess=""
     24939
     24940# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     24941# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     24942# also, we setup the DATA variable
     24943allproj=""
     24944allpcfiles=""
     24945while test "x$projtoprocess" != x ; do
    2460824946
    2460924947  for proj in $projtoprocess ; do
    24610     # if $proj has been processed already, skip this round
    24611     if test "x$projprocessed" != x ; then
    24612       for projdone in $projprocessed ; do
    24613         if test $projdone = $proj ; then
    24614           continue 2
    24615         fi
    24616       done
    24617     fi
    24618 
    2461924948    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2462024949    pcfile=""
     
    2462524954      if test -r "$dir/$proj-uninstalled.pc" ; then
    2462624955        pcfile="$dir/$proj-uninstalled.pc"
    24627         pcfiledir="$dir"
    2462824956        break
    2462924957      fi
     
    2463224960
    2463324961    if test "x$pcfile" != x ; then
    24634       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    24635       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    24636       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    24637       SPX_CFLAGS="$projcflags $SPX_CFLAGS"
    24638 
    24639       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    24640       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    24641       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    24642       if test "x$projlibs" != x ; then
    24643         if test -d "${pcfiledir}/src" ; then
    24644           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    24645         else
    24646           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    24647         fi
    24648       else
    24649         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    24650       fi
    24651       SPX_LIBS="$SPX_LIBS $projlibs"
     24962      # read dependencies from $pcfile and filter it
     24963      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     24964
     24965      # add projrequires to the front of the list of projects that have to be processed next
     24966      # at the same time, remove $proj from this list
     24967      projtoprocess=${projtoprocess/$proj/$projrequires}
    2465224968
    2465324969      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    24654       if test "x$projprocessed" = x ; then
     24970      if test "x$allproj" = x ; then
    2465524971        SPX_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2465624972      fi
    2465724973
    24658       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    24659       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    24660       nextprojtoprocess="$nextprojtoprocess $projrequires"
    24661 
    24662       # remember that we have processed $proj
    24663       projprocessed="$projprocessed $proj"
     24974      allproj="$allproj $proj"
     24975      allpcfiles="$pcfile:$allpcfiles"
    2466424976
    2466524977    else
    2466624978      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2466724979echo "${ECHO_T}no, dependency $proj not available" >&6
     24980      allproj=fail
    2466824981      break 2
    2466924982    fi
    2467024983
     24984    break
    2467124985  done
    2467224986
    24673   projtoprocess="$nextprojtoprocess"
    24674 
    24675   # if there are no more projects to search for, finish up
    24676   if test "x$projtoprocess" = x ; then
    24677     coin_has_spx=yes
    24678     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    24679 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     24987  # remove spaces on begin of $projtoprocess
     24988  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     24989
     24990done
     24991
     24992if test "$allproj" != fail ; then
     24993
     24994  # now go through the list of .pc files and assemble compiler and linker flags
     24995  # important is here to obey the reverse order that has been setup before,
     24996  # since then libraries that are required by several others should be after these other libraries
     24997  pcfilesprocessed=""
     24998
     24999  save_IFS="$IFS"
     25000  IFS=":"
     25001  for pcfile in $allpcfiles ; do
     25002
     25003    # if $pcfile has been processed already, skip this round
     25004    if test "x$pcfilesprocessed" != x ; then
     25005      for pcfiledone in $pcfilesprocessed ; do
     25006        if test "$pcfiledone" = "$pcfile" ; then
     25007          continue 2
     25008        fi
     25009      done
     25010    fi
     25011
     25012    # reconstruct the directory where the .pc file is located
     25013    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     25014
     25015    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     25016    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     25017    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     25018    SPX_CFLAGS="$projcflags $SPX_CFLAGS"
     25019
     25020    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     25021    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     25022    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     25023    if test "x$projlibs" != x ; then
     25024      if test -d "${pcfiledir}/src" ; then
     25025        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     25026      else
     25027        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     25028      fi
     25029    else
     25030      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     25031    fi
     25032    SPX_LIBS="$projlibs $SPX_LIBS"
     25033
     25034    # remember that we have processed $pcfile
     25035    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     25036
     25037  done
     25038  IFS="$save_IFS"
     25039
     25040  # finish up
     25041  coin_has_spx=yes
     25042  echo "$as_me:$LINENO: result: yes" >&5
     25043echo "${ECHO_T}yes" >&6
    2468025044
    2468125045cat >>confdefs.h <<\_ACEOF
     
    2468525049
    2468625050
    24687       CBCGENERIC_PCREQUIRES="osi-soplex $CBCGENERIC_PCREQUIRES"
    24688       CBCGENERIC_CFLAGS="$SPX_CFLAGS $CBCGENERIC_CFLAGS"
    24689       CBCGENERIC_LIBS="$SPX_LIBS $CBCGENERIC_LIBS"
    24690 
    24691 
    24692     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    24693       if test -n "$SPX_CFLAGS" ; then
    24694         { echo "$as_me:$LINENO: Spx CFLAGS are $SPX_CFLAGS" >&5
     25051    CBCGENERIC_PCREQUIRES="osi-soplex $CBCGENERIC_PCREQUIRES"
     25052    CBCGENERIC_CFLAGS="$SPX_CFLAGS $CBCGENERIC_CFLAGS"
     25053    CBCGENERIC_LIBS="$SPX_LIBS $CBCGENERIC_LIBS"
     25054
     25055
     25056  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     25057    if test -n "$SPX_CFLAGS" ; then
     25058      { echo "$as_me:$LINENO: Spx CFLAGS are $SPX_CFLAGS" >&5
    2469525059echo "$as_me: Spx CFLAGS are $SPX_CFLAGS" >&6;}
    24696       fi
    24697       if test -n "$SPX_LIBS" ; then
    24698         { echo "$as_me:$LINENO: Spx LIBS   are $SPX_LIBS" >&5
     25060    fi
     25061    if test -n "$SPX_LIBS" ; then
     25062      { echo "$as_me:$LINENO: Spx LIBS   are $SPX_LIBS" >&5
    2469925063echo "$as_me: Spx LIBS   are $SPX_LIBS" >&6;}
    24700       fi
    24701       if test -n "$SPX_DATA" ; then
    24702         { echo "$as_me:$LINENO: Spx DATA   is  $SPX_DATA" >&5
     25064    fi
     25065    if test -n "$SPX_DATA" ; then
     25066      { echo "$as_me:$LINENO: Spx DATA   is  $SPX_DATA" >&5
    2470325067echo "$as_me: Spx DATA   is  $SPX_DATA" >&6;}
    24704       fi
    24705 
    24706         { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
     25068    fi
     25069
     25070      { echo "$as_me:$LINENO: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&5
    2470725071echo "$as_me: CbcGeneric CFLAGS are $CBCGENERIC_CFLAGS" >&6;}
    24708         { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
     25072      { echo "$as_me:$LINENO: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&5
    2470925073echo "$as_me: CbcGeneric LIBS   are $CBCGENERIC_LIBS" >&6;}
    2471025074
    24711     fi
    2471225075  fi
    24713 done
     25076
     25077fi
    2471425078
    2471525079
     
    2490425268# initial list of dependencies is "osi-xpress", but we need to filter out version number specifications (= x, <= x, >= x)
    2490525269projtoprocess="osi-xpress"
    24906 projprocessed=""
    24907 
    24908 while test $coin_has_xpr = notGiven ; do
    24909   # setup list of projects that need to be processed in the next round
    24910   nextprojtoprocess=""
     25270
     25271# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     25272# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     25273# also, we setup the DATA variable
     25274allproj=""
     25275allpcfiles=""
     25276while test "x$projtoprocess" != x ; do
    2491125277
    2491225278  for proj in $projtoprocess ; do
    24913     # if $proj has been processed already, skip this round
    24914     if test "x$projprocessed" != x ; then
    24915       for projdone in $projprocessed ; do
    24916         if test $projdone = $proj ; then
    24917           continue 2
    24918         fi
    24919       done
    24920     fi
    24921 
    2492225279    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2492325280    pcfile=""
     
    2492825285      if test -r "$dir/$proj-uninstalled.pc" ; then
    2492925286        pcfile="$dir/$proj-uninstalled.pc"
    24930         pcfiledir="$dir"
    2493125287        break
    2493225288      fi
     
    2493525291
    2493625292    if test "x$pcfile" != x ; then
    24937       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    24938       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    24939       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    24940       XPR_CFLAGS="$projcflags $XPR_CFLAGS"
    24941 
    24942       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    24943       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    24944       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    24945       if test "x$projlibs" != x ; then
    24946         if test -d "${pcfiledir}/src" ; then
    24947           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    24948         else
    24949           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    24950         fi
    24951       else
    24952         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    24953       fi
    24954       XPR_LIBS="$XPR_LIBS $projlibs"
     25293      # read dependencies from $pcfile and filter it
     25294      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     25295
     25296      # add projrequires to the front of the list of projects that have to be processed next
     25297      # at the same time, remove $proj from this list
     25298      projtoprocess=${projtoprocess/$proj/$projrequires}
    2495525299
    2495625300      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    24957       if test "x$projprocessed" = x ; then
     25301      if test "x$allproj" = x ; then
    2495825302        XPR_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2495925303      fi
    2496025304
    24961       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    24962       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    24963       nextprojtoprocess="$nextprojtoprocess $projrequires"
    24964 
    24965       # remember that we have processed $proj
    24966       projprocessed="$projprocessed $proj"
     25305      allproj="$allproj $proj"
     25306      allpcfiles="$pcfile:$allpcfiles"
    2496725307
    2496825308    else
    2496925309      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2497025310echo "${ECHO_T}no, dependency $proj not available" >&6
     25311      allproj=fail
    2497125312      break 2
    2497225313    fi
    2497325314
     25315    break
    2497425316  done
    2497525317
    24976   projtoprocess="$nextprojtoprocess"
    24977 
    24978   # if there are no more projects to search for, finish up
    24979   if test "x$projtoprocess" = x ; then
    24980     coin_has_xpr=yes
    24981     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    24982 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     25318  # remove spaces on begin of $projtoprocess
     25319  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     25320
     25321done
     25322
     25323if test "$allproj" != fail ; then
     25324
     25325  # now go through the list of .pc files and assemble compiler and linker flags
     25326  # important is here to obey the reverse order that has been setup before,
     25327  # since then libraries that are required by several others should be after these other libraries
     25328  pcfilesprocessed=""
     25329
     25330  save_IFS="$IFS"
     25331  IFS=":"
     25332  for pcfile in $allpcfiles ; do
     25333
     25334    # if $pcfile has been processed already, skip this round
     25335    if test "x$pcfilesprocessed" != x ; then
     25336      for pcfiledone in $pcfilesprocessed ; do
     25337        if test "$pcfiledone" = "$pcfile" ; then
     25338          continue 2
     25339        fi
     25340      done
     25341    fi
     25342
     25343    # reconstruct the directory where the .pc file is located
     25344    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     25345
     25346    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     25347    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     25348    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     25349    XPR_CFLAGS="$projcflags $XPR_CFLAGS"
     25350
     25351    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     25352    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     25353    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     25354    if test "x$projlibs" != x ; then
     25355      if test -d "${pcfiledir}/src" ; then
     25356        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     25357      else
     25358        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     25359      fi
     25360    else
     25361      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     25362    fi
     25363    XPR_LIBS="$projlibs $XPR_LIBS"
     25364
     25365    # remember that we have processed $pcfile
     25366    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     25367
     25368  done
     25369  IFS="$save_IFS"
     25370
     25371  # finish up
     25372  coin_has_xpr=yes
     25373  echo "$as_me:$LINENO: result: yes" >&5
     25374echo "${ECHO_T}yes" >&6
    2498325375
    2498425376cat >>confdefs.h <<\_ACEOF
     
    2498925381
    2499025382
    24991     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    24992       if test -n "$XPR_CFLAGS" ; then
    24993         { echo "$as_me:$LINENO: Xpr CFLAGS are $XPR_CFLAGS" >&5
     25383  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     25384    if test -n "$XPR_CFLAGS" ; then
     25385      { echo "$as_me:$LINENO: Xpr CFLAGS are $XPR_CFLAGS" >&5
    2499425386echo "$as_me: Xpr CFLAGS are $XPR_CFLAGS" >&6;}
    24995       fi
    24996       if test -n "$XPR_LIBS" ; then
    24997         { echo "$as_me:$LINENO: Xpr LIBS   are $XPR_LIBS" >&5
     25387    fi
     25388    if test -n "$XPR_LIBS" ; then
     25389      { echo "$as_me:$LINENO: Xpr LIBS   are $XPR_LIBS" >&5
    2499825390echo "$as_me: Xpr LIBS   are $XPR_LIBS" >&6;}
    24999       fi
    25000       if test -n "$XPR_DATA" ; then
    25001         { echo "$as_me:$LINENO: Xpr DATA   is  $XPR_DATA" >&5
     25391    fi
     25392    if test -n "$XPR_DATA" ; then
     25393      { echo "$as_me:$LINENO: Xpr DATA   is  $XPR_DATA" >&5
    2500225394echo "$as_me: Xpr DATA   is  $XPR_DATA" >&6;}
    25003       fi
    25004 
    2500525395    fi
     25396
    2500625397  fi
    25007 done
     25398
     25399fi
    2500825400
    2500925401
     
    2519925591# initial list of dependencies is "coinasl", but we need to filter out version number specifications (= x, <= x, >= x)
    2520025592projtoprocess="coinasl"
    25201 projprocessed=""
    25202 
    25203 while test $coin_has_asl = notGiven ; do
    25204   # setup list of projects that need to be processed in the next round
    25205   nextprojtoprocess=""
     25593
     25594# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     25595# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     25596# also, we setup the DATA variable
     25597allproj=""
     25598allpcfiles=""
     25599while test "x$projtoprocess" != x ; do
    2520625600
    2520725601  for proj in $projtoprocess ; do
    25208     # if $proj has been processed already, skip this round
    25209     if test "x$projprocessed" != x ; then
    25210       for projdone in $projprocessed ; do
    25211         if test $projdone = $proj ; then
    25212           continue 2
    25213         fi
    25214       done
    25215     fi
    25216 
    2521725602    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2521825603    pcfile=""
     
    2522325608      if test -r "$dir/$proj-uninstalled.pc" ; then
    2522425609        pcfile="$dir/$proj-uninstalled.pc"
    25225         pcfiledir="$dir"
    2522625610        break
    2522725611      fi
     
    2523025614
    2523125615    if test "x$pcfile" != x ; then
    25232       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    25233       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    25234       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    25235       ASL_CFLAGS="$projcflags $ASL_CFLAGS"
    25236 
    25237       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    25238       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    25239       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    25240       if test "x$projlibs" != x ; then
    25241         if test -d "${pcfiledir}/src" ; then
    25242           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    25243         else
    25244           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    25245         fi
    25246       else
    25247         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    25248       fi
    25249       ASL_LIBS="$ASL_LIBS $projlibs"
     25616      # read dependencies from $pcfile and filter it
     25617      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     25618
     25619      # add projrequires to the front of the list of projects that have to be processed next
     25620      # at the same time, remove $proj from this list
     25621      projtoprocess=${projtoprocess/$proj/$projrequires}
    2525025622
    2525125623      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    25252       if test "x$projprocessed" = x ; then
     25624      if test "x$allproj" = x ; then
    2525325625        ASL_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2525425626      fi
    2525525627
    25256       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    25257       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\?>\?=[  ]*[^    ]\+//g'`
    25258       nextprojtoprocess="$nextprojtoprocess $projrequires"
    25259 
    25260       # remember that we have processed $proj
    25261       projprocessed="$projprocessed $proj"
     25628      allproj="$allproj $proj"
     25629      allpcfiles="$pcfile:$allpcfiles"
    2526225630
    2526325631    else
    2526425632      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2526525633echo "${ECHO_T}no, dependency $proj not available" >&6
     25634      allproj=fail
    2526625635      break 2
    2526725636    fi
    2526825637
     25638    break
    2526925639  done
    2527025640
    25271   projtoprocess="$nextprojtoprocess"
    25272 
    25273   # if there are no more projects to search for, finish up
    25274   if test "x$projtoprocess" = x ; then
    25275     coin_has_asl=yes
    25276     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    25277 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     25641  # remove spaces on begin of $projtoprocess
     25642  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     25643
     25644done
     25645
     25646if test "$allproj" != fail ; then
     25647
     25648  # now go through the list of .pc files and assemble compiler and linker flags
     25649  # important is here to obey the reverse order that has been setup before,
     25650  # since then libraries that are required by several others should be after these other libraries
     25651  pcfilesprocessed=""
     25652
     25653  save_IFS="$IFS"
     25654  IFS=":"
     25655  for pcfile in $allpcfiles ; do
     25656
     25657    # if $pcfile has been processed already, skip this round
     25658    if test "x$pcfilesprocessed" != x ; then
     25659      for pcfiledone in $pcfilesprocessed ; do
     25660        if test "$pcfiledone" = "$pcfile" ; then
     25661          continue 2
     25662        fi
     25663      done
     25664    fi
     25665
     25666    # reconstruct the directory where the .pc file is located
     25667    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     25668
     25669    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     25670    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     25671    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     25672    ASL_CFLAGS="$projcflags $ASL_CFLAGS"
     25673
     25674    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     25675    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     25676    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     25677    if test "x$projlibs" != x ; then
     25678      if test -d "${pcfiledir}/src" ; then
     25679        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     25680      else
     25681        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     25682      fi
     25683    else
     25684      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     25685    fi
     25686    ASL_LIBS="$projlibs $ASL_LIBS"
     25687
     25688    # remember that we have processed $pcfile
     25689    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     25690
     25691  done
     25692  IFS="$save_IFS"
     25693
     25694  # finish up
     25695  coin_has_asl=yes
     25696  echo "$as_me:$LINENO: result: yes" >&5
     25697echo "${ECHO_T}yes" >&6
    2527825698
    2527925699cat >>confdefs.h <<\_ACEOF
     
    2528425704
    2528525705
    25286     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    25287       if test -n "$ASL_CFLAGS" ; then
    25288         { echo "$as_me:$LINENO: ASL CFLAGS are $ASL_CFLAGS" >&5
     25706  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     25707    if test -n "$ASL_CFLAGS" ; then
     25708      { echo "$as_me:$LINENO: ASL CFLAGS are $ASL_CFLAGS" >&5
    2528925709echo "$as_me: ASL CFLAGS are $ASL_CFLAGS" >&6;}
    25290       fi
    25291       if test -n "$ASL_LIBS" ; then
    25292         { echo "$as_me:$LINENO: ASL LIBS   are $ASL_LIBS" >&5
     25710    fi
     25711    if test -n "$ASL_LIBS" ; then
     25712      { echo "$as_me:$LINENO: ASL LIBS   are $ASL_LIBS" >&5
    2529325713echo "$as_me: ASL LIBS   are $ASL_LIBS" >&6;}
    25294       fi
    25295       if test -n "$ASL_DATA" ; then
    25296         { echo "$as_me:$LINENO: ASL DATA   is  $ASL_DATA" >&5
     25714    fi
     25715    if test -n "$ASL_DATA" ; then
     25716      { echo "$as_me:$LINENO: ASL DATA   is  $ASL_DATA" >&5
    2529725717echo "$as_me: ASL DATA   is  $ASL_DATA" >&6;}
    25298       fi
    25299 
    2530025718    fi
     25719
    2530125720  fi
    25302 done
     25721
     25722fi
    2530325723
    2530425724
Note: See TracChangeset for help on using the changeset viewer.