Changeset 1634 for stable


Ignore:
Timestamp:
Nov 22, 2010 5:14:03 PM (9 years ago)
Author:
stefan
Message:

rerun autotools

File:
1 edited

Legend:

Unmodified
Added
Removed
  • stable/1.13/Clp/configure

    r1633 r1634  
    2083220832# initial list of dependencies is "coinutils", but we need to filter out version number specifications (= x, <= x, >= x)
    2083320833projtoprocess="coinutils"
    20834 projprocessed=""
    20835 
    20836 while test $coin_has_coinutils = notGiven ; do
    20837   # setup list of projects that need to be processed in the next round
    20838   nextprojtoprocess=""
     20834
     20835# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     20836# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     20837# also, we setup the DATA variable
     20838allproj=""
     20839allpcfiles=""
     20840while test "x$projtoprocess" != x ; do
    2083920841
    2084020842  for proj in $projtoprocess ; do
    20841     # if $proj has been processed already, skip this round
    20842     if test "x$projprocessed" != x ; then
    20843       for projdone in $projprocessed ; do
    20844         if test $projdone = $proj ; then
    20845           continue 2
    20846         fi
    20847       done
    20848     fi
    20849 
    2085020843    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2085120844    pcfile=""
     
    2085620849      if test -r "$dir/$proj-uninstalled.pc" ; then
    2085720850        pcfile="$dir/$proj-uninstalled.pc"
    20858         pcfiledir="$dir"
    2085920851        break
    2086020852      fi
     
    2086320855
    2086420856    if test "x$pcfile" != x ; then
    20865       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    20866       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    20867       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    20868       COINUTILS_CFLAGS="$projcflags $COINUTILS_CFLAGS"
    20869 
    20870       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    20871       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    20872       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    20873       if test "x$projlibs" != x ; then
    20874         if test -d "${pcfiledir}/src" ; then
    20875           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    20876         else
    20877           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    20878         fi
    20879       else
    20880         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    20881       fi
    20882       COINUTILS_LIBS="$COINUTILS_LIBS $projlibs"
     20857      # read dependencies from $pcfile and filter it
     20858      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     20859
     20860      # add projrequires to the front of the list of projects that have to be processed next
     20861      # at the same time, remove $proj from this list
     20862      projtoprocess=${projtoprocess/$proj/$projrequires}
    2088320863
    2088420864      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    20885       if test "x$projprocessed" = x ; then
     20865      if test "x$allproj" = x ; then
    2088620866        COINUTILS_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2088720867      fi
    2088820868
    20889       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    20890       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
    20891       nextprojtoprocess="$nextprojtoprocess $projrequires"
    20892 
    20893       # remember that we have processed $proj
    20894       projprocessed="$projprocessed $proj"
     20869      allproj="$allproj $proj"
     20870      allpcfiles="$pcfile:$allpcfiles"
    2089520871
    2089620872    else
    2089720873      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2089820874echo "${ECHO_T}no, dependency $proj not available" >&6
     20875      allproj=fail
    2089920876      break 2
    2090020877    fi
    2090120878
     20879    break
    2090220880  done
    2090320881
    20904   projtoprocess="$nextprojtoprocess"
    20905 
    20906   # if there are no more projects to search for, finish up
    20907   if test "x$projtoprocess" = x ; then
    20908     coin_has_coinutils=yes
    20909     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    20910 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     20882  # remove spaces on begin of $projtoprocess
     20883  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     20884
     20885done
     20886
     20887if test "$allproj" != fail ; then
     20888
     20889  # now go through the list of .pc files and assemble compiler and linker flags
     20890  # important is here to obey the reverse order that has been setup before,
     20891  # since then libraries that are required by several others should be after these other libraries
     20892  pcfilesprocessed=""
     20893
     20894  save_IFS="$IFS"
     20895  IFS=":"
     20896  for pcfile in $allpcfiles ; do
     20897
     20898    # if $pcfile has been processed already, skip this round
     20899    if test "x$pcfilesprocessed" != x ; then
     20900      for pcfiledone in $pcfilesprocessed ; do
     20901        if test "$pcfiledone" = "$pcfile" ; then
     20902          continue 2
     20903        fi
     20904      done
     20905    fi
     20906
     20907    # reconstruct the directory where the .pc file is located
     20908    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     20909
     20910    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     20911    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     20912    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     20913    COINUTILS_CFLAGS="$projcflags $COINUTILS_CFLAGS"
     20914
     20915    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     20916    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     20917    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     20918    if test "x$projlibs" != x ; then
     20919      if test -d "${pcfiledir}/src" ; then
     20920        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     20921      else
     20922        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     20923      fi
     20924    else
     20925      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     20926    fi
     20927    COINUTILS_LIBS="$projlibs $COINUTILS_LIBS"
     20928
     20929    # remember that we have processed $pcfile
     20930    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     20931
     20932  done
     20933  IFS="$save_IFS"
     20934
     20935  # finish up
     20936  coin_has_coinutils=yes
     20937  echo "$as_me:$LINENO: result: yes" >&5
     20938echo "${ECHO_T}yes" >&6
    2091120939
    2091220940cat >>confdefs.h <<\_ACEOF
     
    2091620944
    2091720945
    20918       CLPLIB_PCREQUIRES="coinutils $CLPLIB_PCREQUIRES"
    20919       CLPLIB_CFLAGS="$COINUTILS_CFLAGS $CLPLIB_CFLAGS"
    20920       CLPLIB_LIBS="$COINUTILS_LIBS $CLPLIB_LIBS"
    20921 
    20922 
    20923     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    20924       if test -n "$COINUTILS_CFLAGS" ; then
    20925         { echo "$as_me:$LINENO: CoinUtils CFLAGS are $COINUTILS_CFLAGS" >&5
     20946    CLPLIB_PCREQUIRES="coinutils $CLPLIB_PCREQUIRES"
     20947    CLPLIB_CFLAGS="$COINUTILS_CFLAGS $CLPLIB_CFLAGS"
     20948    CLPLIB_LIBS="$COINUTILS_LIBS $CLPLIB_LIBS"
     20949
     20950
     20951  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     20952    if test -n "$COINUTILS_CFLAGS" ; then
     20953      { echo "$as_me:$LINENO: CoinUtils CFLAGS are $COINUTILS_CFLAGS" >&5
    2092620954echo "$as_me: CoinUtils CFLAGS are $COINUTILS_CFLAGS" >&6;}
    20927       fi
    20928       if test -n "$COINUTILS_LIBS" ; then
    20929         { echo "$as_me:$LINENO: CoinUtils LIBS   are $COINUTILS_LIBS" >&5
     20955    fi
     20956    if test -n "$COINUTILS_LIBS" ; then
     20957      { echo "$as_me:$LINENO: CoinUtils LIBS   are $COINUTILS_LIBS" >&5
    2093020958echo "$as_me: CoinUtils LIBS   are $COINUTILS_LIBS" >&6;}
    20931       fi
    20932       if test -n "$COINUTILS_DATA" ; then
    20933         { echo "$as_me:$LINENO: CoinUtils DATA   is  $COINUTILS_DATA" >&5
     20959    fi
     20960    if test -n "$COINUTILS_DATA" ; then
     20961      { echo "$as_me:$LINENO: CoinUtils DATA   is  $COINUTILS_DATA" >&5
    2093420962echo "$as_me: CoinUtils DATA   is  $COINUTILS_DATA" >&6;}
    20935       fi
    20936 
    20937         { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
     20963    fi
     20964
     20965      { echo "$as_me:$LINENO: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&5
    2093820966echo "$as_me: ClpLib CFLAGS are $CLPLIB_CFLAGS" >&6;}
    20939         { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
     20967      { echo "$as_me:$LINENO: ClpLib LIBS   are $CLPLIB_LIBS" >&5
    2094020968echo "$as_me: ClpLib LIBS   are $CLPLIB_LIBS" >&6;}
    2094120969
    20942     fi
    2094320970  fi
    20944 done
     20971
     20972fi
    2094520973
    2094620974
     
    2114821176# initial list of dependencies is "osi", but we need to filter out version number specifications (= x, <= x, >= x)
    2114921177projtoprocess="osi"
    21150 projprocessed=""
    21151 
    21152 while test $coin_has_osi = notGiven ; do
    21153   # setup list of projects that need to be processed in the next round
    21154   nextprojtoprocess=""
     21178
     21179# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     21180# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     21181# also, we setup the DATA variable
     21182allproj=""
     21183allpcfiles=""
     21184while test "x$projtoprocess" != x ; do
    2115521185
    2115621186  for proj in $projtoprocess ; do
    21157     # if $proj has been processed already, skip this round
    21158     if test "x$projprocessed" != x ; then
    21159       for projdone in $projprocessed ; do
    21160         if test $projdone = $proj ; then
    21161           continue 2
    21162         fi
    21163       done
    21164     fi
    21165 
    2116621187    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2116721188    pcfile=""
     
    2117221193      if test -r "$dir/$proj-uninstalled.pc" ; then
    2117321194        pcfile="$dir/$proj-uninstalled.pc"
    21174         pcfiledir="$dir"
    2117521195        break
    2117621196      fi
     
    2117921199
    2118021200    if test "x$pcfile" != x ; then
    21181       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    21182       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    21183       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    21184       OSI_CFLAGS="$projcflags $OSI_CFLAGS"
    21185 
    21186       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    21187       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    21188       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    21189       if test "x$projlibs" != x ; then
    21190         if test -d "${pcfiledir}/src" ; then
    21191           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    21192         else
    21193           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    21194         fi
    21195       else
    21196         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    21197       fi
    21198       OSI_LIBS="$OSI_LIBS $projlibs"
     21201      # read dependencies from $pcfile and filter it
     21202      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     21203
     21204      # add projrequires to the front of the list of projects that have to be processed next
     21205      # at the same time, remove $proj from this list
     21206      projtoprocess=${projtoprocess/$proj/$projrequires}
    2119921207
    2120021208      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    21201       if test "x$projprocessed" = x ; then
     21209      if test "x$allproj" = x ; then
    2120221210        OSI_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2120321211      fi
    2120421212
    21205       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    21206       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
    21207       nextprojtoprocess="$nextprojtoprocess $projrequires"
    21208 
    21209       # remember that we have processed $proj
    21210       projprocessed="$projprocessed $proj"
     21213      allproj="$allproj $proj"
     21214      allpcfiles="$pcfile:$allpcfiles"
    2121121215
    2121221216    else
    2121321217      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2121421218echo "${ECHO_T}no, dependency $proj not available" >&6
     21219      allproj=fail
    2121521220      break 2
    2121621221    fi
    2121721222
     21223    break
    2121821224  done
    2121921225
    21220   projtoprocess="$nextprojtoprocess"
    21221 
    21222   # if there are no more projects to search for, finish up
    21223   if test "x$projtoprocess" = x ; then
    21224     coin_has_osi=yes
    21225     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    21226 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     21226  # remove spaces on begin of $projtoprocess
     21227  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     21228
     21229done
     21230
     21231if test "$allproj" != fail ; then
     21232
     21233  # now go through the list of .pc files and assemble compiler and linker flags
     21234  # important is here to obey the reverse order that has been setup before,
     21235  # since then libraries that are required by several others should be after these other libraries
     21236  pcfilesprocessed=""
     21237
     21238  save_IFS="$IFS"
     21239  IFS=":"
     21240  for pcfile in $allpcfiles ; do
     21241
     21242    # if $pcfile has been processed already, skip this round
     21243    if test "x$pcfilesprocessed" != x ; then
     21244      for pcfiledone in $pcfilesprocessed ; do
     21245        if test "$pcfiledone" = "$pcfile" ; then
     21246          continue 2
     21247        fi
     21248      done
     21249    fi
     21250
     21251    # reconstruct the directory where the .pc file is located
     21252    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     21253
     21254    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21255    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     21256    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     21257    OSI_CFLAGS="$projcflags $OSI_CFLAGS"
     21258
     21259    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21260    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21261    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21262    if test "x$projlibs" != x ; then
     21263      if test -d "${pcfiledir}/src" ; then
     21264        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21265      else
     21266        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21267      fi
     21268    else
     21269      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     21270    fi
     21271    OSI_LIBS="$projlibs $OSI_LIBS"
     21272
     21273    # remember that we have processed $pcfile
     21274    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     21275
     21276  done
     21277  IFS="$save_IFS"
     21278
     21279  # finish up
     21280  coin_has_osi=yes
     21281  echo "$as_me:$LINENO: result: yes" >&5
     21282echo "${ECHO_T}yes" >&6
    2122721283
    2122821284cat >>confdefs.h <<\_ACEOF
     
    2123221288
    2123321289
    21234       OSICLPLIB_PCREQUIRES="osi $OSICLPLIB_PCREQUIRES"
    21235       OSICLPLIB_CFLAGS="$OSI_CFLAGS $OSICLPLIB_CFLAGS"
    21236       OSICLPLIB_LIBS="$OSI_LIBS $OSICLPLIB_LIBS"
    21237 
    21238 
    21239     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    21240       if test -n "$OSI_CFLAGS" ; then
    21241         { echo "$as_me:$LINENO: Osi CFLAGS are $OSI_CFLAGS" >&5
     21290    OSICLPLIB_PCREQUIRES="osi $OSICLPLIB_PCREQUIRES"
     21291    OSICLPLIB_CFLAGS="$OSI_CFLAGS $OSICLPLIB_CFLAGS"
     21292    OSICLPLIB_LIBS="$OSI_LIBS $OSICLPLIB_LIBS"
     21293
     21294
     21295  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21296    if test -n "$OSI_CFLAGS" ; then
     21297      { echo "$as_me:$LINENO: Osi CFLAGS are $OSI_CFLAGS" >&5
    2124221298echo "$as_me: Osi CFLAGS are $OSI_CFLAGS" >&6;}
    21243       fi
    21244       if test -n "$OSI_LIBS" ; then
    21245         { echo "$as_me:$LINENO: Osi LIBS   are $OSI_LIBS" >&5
     21299    fi
     21300    if test -n "$OSI_LIBS" ; then
     21301      { echo "$as_me:$LINENO: Osi LIBS   are $OSI_LIBS" >&5
    2124621302echo "$as_me: Osi LIBS   are $OSI_LIBS" >&6;}
    21247       fi
    21248       if test -n "$OSI_DATA" ; then
    21249         { echo "$as_me:$LINENO: Osi DATA   is  $OSI_DATA" >&5
     21303    fi
     21304    if test -n "$OSI_DATA" ; then
     21305      { echo "$as_me:$LINENO: Osi DATA   is  $OSI_DATA" >&5
    2125021306echo "$as_me: Osi DATA   is  $OSI_DATA" >&6;}
    21251       fi
    21252 
    21253         { echo "$as_me:$LINENO: OsiClpLib CFLAGS are $OSICLPLIB_CFLAGS" >&5
     21307    fi
     21308
     21309      { echo "$as_me:$LINENO: OsiClpLib CFLAGS are $OSICLPLIB_CFLAGS" >&5
    2125421310echo "$as_me: OsiClpLib CFLAGS are $OSICLPLIB_CFLAGS" >&6;}
    21255         { echo "$as_me:$LINENO: OsiClpLib LIBS   are $OSICLPLIB_LIBS" >&5
     21311      { echo "$as_me:$LINENO: OsiClpLib LIBS   are $OSICLPLIB_LIBS" >&5
    2125621312echo "$as_me: OsiClpLib LIBS   are $OSICLPLIB_LIBS" >&6;}
    2125721313
    21258     fi
    2125921314  fi
    21260 done
     21315
     21316fi
    2126121317
    2126221318
     
    2145121507# initial list of dependencies is "osi-unittests", but we need to filter out version number specifications (= x, <= x, >= x)
    2145221508projtoprocess="osi-unittests"
    21453 projprocessed=""
    21454 
    21455 while test $coin_has_ositests = notGiven ; do
    21456   # setup list of projects that need to be processed in the next round
    21457   nextprojtoprocess=""
     21509
     21510# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     21511# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     21512# also, we setup the DATA variable
     21513allproj=""
     21514allpcfiles=""
     21515while test "x$projtoprocess" != x ; do
    2145821516
    2145921517  for proj in $projtoprocess ; do
    21460     # if $proj has been processed already, skip this round
    21461     if test "x$projprocessed" != x ; then
    21462       for projdone in $projprocessed ; do
    21463         if test $projdone = $proj ; then
    21464           continue 2
    21465         fi
    21466       done
    21467     fi
    21468 
    2146921518    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2147021519    pcfile=""
     
    2147521524      if test -r "$dir/$proj-uninstalled.pc" ; then
    2147621525        pcfile="$dir/$proj-uninstalled.pc"
    21477         pcfiledir="$dir"
    2147821526        break
    2147921527      fi
     
    2148221530
    2148321531    if test "x$pcfile" != x ; then
    21484       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    21485       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    21486       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    21487       OSITESTS_CFLAGS="$projcflags $OSITESTS_CFLAGS"
    21488 
    21489       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    21490       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    21491       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    21492       if test "x$projlibs" != x ; then
    21493         if test -d "${pcfiledir}/src" ; then
    21494           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    21495         else
    21496           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    21497         fi
    21498       else
    21499         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    21500       fi
    21501       OSITESTS_LIBS="$OSITESTS_LIBS $projlibs"
     21532      # read dependencies from $pcfile and filter it
     21533      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     21534
     21535      # add projrequires to the front of the list of projects that have to be processed next
     21536      # at the same time, remove $proj from this list
     21537      projtoprocess=${projtoprocess/$proj/$projrequires}
    2150221538
    2150321539      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    21504       if test "x$projprocessed" = x ; then
     21540      if test "x$allproj" = x ; then
    2150521541        OSITESTS_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2150621542      fi
    2150721543
    21508       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    21509       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
    21510       nextprojtoprocess="$nextprojtoprocess $projrequires"
    21511 
    21512       # remember that we have processed $proj
    21513       projprocessed="$projprocessed $proj"
     21544      allproj="$allproj $proj"
     21545      allpcfiles="$pcfile:$allpcfiles"
    2151421546
    2151521547    else
    2151621548      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2151721549echo "${ECHO_T}no, dependency $proj not available" >&6
     21550      allproj=fail
    2151821551      break 2
    2151921552    fi
    2152021553
     21554    break
    2152121555  done
    2152221556
    21523   projtoprocess="$nextprojtoprocess"
    21524 
    21525   # if there are no more projects to search for, finish up
    21526   if test "x$projtoprocess" = x ; then
    21527     coin_has_ositests=yes
    21528     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    21529 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     21557  # remove spaces on begin of $projtoprocess
     21558  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     21559
     21560done
     21561
     21562if test "$allproj" != fail ; then
     21563
     21564  # now go through the list of .pc files and assemble compiler and linker flags
     21565  # important is here to obey the reverse order that has been setup before,
     21566  # since then libraries that are required by several others should be after these other libraries
     21567  pcfilesprocessed=""
     21568
     21569  save_IFS="$IFS"
     21570  IFS=":"
     21571  for pcfile in $allpcfiles ; do
     21572
     21573    # if $pcfile has been processed already, skip this round
     21574    if test "x$pcfilesprocessed" != x ; then
     21575      for pcfiledone in $pcfilesprocessed ; do
     21576        if test "$pcfiledone" = "$pcfile" ; then
     21577          continue 2
     21578        fi
     21579      done
     21580    fi
     21581
     21582    # reconstruct the directory where the .pc file is located
     21583    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     21584
     21585    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21586    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     21587    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     21588    OSITESTS_CFLAGS="$projcflags $OSITESTS_CFLAGS"
     21589
     21590    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21591    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21592    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21593    if test "x$projlibs" != x ; then
     21594      if test -d "${pcfiledir}/src" ; then
     21595        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21596      else
     21597        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21598      fi
     21599    else
     21600      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     21601    fi
     21602    OSITESTS_LIBS="$projlibs $OSITESTS_LIBS"
     21603
     21604    # remember that we have processed $pcfile
     21605    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     21606
     21607  done
     21608  IFS="$save_IFS"
     21609
     21610  # finish up
     21611  coin_has_ositests=yes
     21612  echo "$as_me:$LINENO: result: yes" >&5
     21613echo "${ECHO_T}yes" >&6
    2153021614
    2153121615cat >>confdefs.h <<\_ACEOF
     
    2153621620
    2153721621
    21538     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    21539       if test -n "$OSITESTS_CFLAGS" ; then
    21540         { echo "$as_me:$LINENO: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&5
     21622  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21623    if test -n "$OSITESTS_CFLAGS" ; then
     21624      { echo "$as_me:$LINENO: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&5
    2154121625echo "$as_me: OsiTests CFLAGS are $OSITESTS_CFLAGS" >&6;}
    21542       fi
    21543       if test -n "$OSITESTS_LIBS" ; then
    21544         { echo "$as_me:$LINENO: OsiTests LIBS   are $OSITESTS_LIBS" >&5
     21626    fi
     21627    if test -n "$OSITESTS_LIBS" ; then
     21628      { echo "$as_me:$LINENO: OsiTests LIBS   are $OSITESTS_LIBS" >&5
    2154521629echo "$as_me: OsiTests LIBS   are $OSITESTS_LIBS" >&6;}
    21546       fi
    21547       if test -n "$OSITESTS_DATA" ; then
    21548         { echo "$as_me:$LINENO: OsiTests DATA   is  $OSITESTS_DATA" >&5
     21630    fi
     21631    if test -n "$OSITESTS_DATA" ; then
     21632      { echo "$as_me:$LINENO: OsiTests DATA   is  $OSITESTS_DATA" >&5
    2154921633echo "$as_me: OsiTests DATA   is  $OSITESTS_DATA" >&6;}
    21550       fi
    21551 
    2155221634    fi
     21635
    2155321636  fi
    21554 done
     21637
     21638fi
    2155521639
    2155621640
     
    2174021824# initial list of dependencies is "coindatasample", but we need to filter out version number specifications (= x, <= x, >= x)
    2174121825projtoprocess="coindatasample"
    21742 projprocessed=""
    21743 
    21744 while test $coin_has_sample = notGiven ; do
    21745   # setup list of projects that need to be processed in the next round
    21746   nextprojtoprocess=""
     21826
     21827# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     21828# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     21829# also, we setup the DATA variable
     21830allproj=""
     21831allpcfiles=""
     21832while test "x$projtoprocess" != x ; do
    2174721833
    2174821834  for proj in $projtoprocess ; do
    21749     # if $proj has been processed already, skip this round
    21750     if test "x$projprocessed" != x ; then
    21751       for projdone in $projprocessed ; do
    21752         if test $projdone = $proj ; then
    21753           continue 2
    21754         fi
    21755       done
    21756     fi
    21757 
    2175821835    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2175921836    pcfile=""
     
    2176421841      if test -r "$dir/$proj-uninstalled.pc" ; then
    2176521842        pcfile="$dir/$proj-uninstalled.pc"
    21766         pcfiledir="$dir"
    2176721843        break
    2176821844      fi
     
    2177121847
    2177221848    if test "x$pcfile" != x ; then
    21773       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    21774       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    21775       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    21776       SAMPLE_CFLAGS="$projcflags $SAMPLE_CFLAGS"
    21777 
    21778       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    21779       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    21780       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    21781       if test "x$projlibs" != x ; then
    21782         if test -d "${pcfiledir}/src" ; then
    21783           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    21784         else
    21785           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    21786         fi
    21787       else
    21788         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    21789       fi
    21790       SAMPLE_LIBS="$SAMPLE_LIBS $projlibs"
     21849      # read dependencies from $pcfile and filter it
     21850      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     21851
     21852      # add projrequires to the front of the list of projects that have to be processed next
     21853      # at the same time, remove $proj from this list
     21854      projtoprocess=${projtoprocess/$proj/$projrequires}
    2179121855
    2179221856      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    21793       if test "x$projprocessed" = x ; then
     21857      if test "x$allproj" = x ; then
    2179421858        SAMPLE_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2179521859      fi
    2179621860
    21797       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    21798       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
    21799       nextprojtoprocess="$nextprojtoprocess $projrequires"
    21800 
    21801       # remember that we have processed $proj
    21802       projprocessed="$projprocessed $proj"
     21861      allproj="$allproj $proj"
     21862      allpcfiles="$pcfile:$allpcfiles"
    2180321863
    2180421864    else
    2180521865      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2180621866echo "${ECHO_T}no, dependency $proj not available" >&6
     21867      allproj=fail
    2180721868      break 2
    2180821869    fi
    2180921870
     21871    break
    2181021872  done
    2181121873
    21812   projtoprocess="$nextprojtoprocess"
    21813 
    21814   # if there are no more projects to search for, finish up
    21815   if test "x$projtoprocess" = x ; then
    21816     coin_has_sample=yes
    21817     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    21818 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     21874  # remove spaces on begin of $projtoprocess
     21875  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     21876
     21877done
     21878
     21879if test "$allproj" != fail ; then
     21880
     21881  # now go through the list of .pc files and assemble compiler and linker flags
     21882  # important is here to obey the reverse order that has been setup before,
     21883  # since then libraries that are required by several others should be after these other libraries
     21884  pcfilesprocessed=""
     21885
     21886  save_IFS="$IFS"
     21887  IFS=":"
     21888  for pcfile in $allpcfiles ; do
     21889
     21890    # if $pcfile has been processed already, skip this round
     21891    if test "x$pcfilesprocessed" != x ; then
     21892      for pcfiledone in $pcfilesprocessed ; do
     21893        if test "$pcfiledone" = "$pcfile" ; then
     21894          continue 2
     21895        fi
     21896      done
     21897    fi
     21898
     21899    # reconstruct the directory where the .pc file is located
     21900    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     21901
     21902    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     21903    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     21904    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     21905    SAMPLE_CFLAGS="$projcflags $SAMPLE_CFLAGS"
     21906
     21907    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     21908    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     21909    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     21910    if test "x$projlibs" != x ; then
     21911      if test -d "${pcfiledir}/src" ; then
     21912        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     21913      else
     21914        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     21915      fi
     21916    else
     21917      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     21918    fi
     21919    SAMPLE_LIBS="$projlibs $SAMPLE_LIBS"
     21920
     21921    # remember that we have processed $pcfile
     21922    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     21923
     21924  done
     21925  IFS="$save_IFS"
     21926
     21927  # finish up
     21928  coin_has_sample=yes
     21929  echo "$as_me:$LINENO: result: yes" >&5
     21930echo "${ECHO_T}yes" >&6
    2181921931
    2182021932cat >>confdefs.h <<\_ACEOF
     
    2182521937
    2182621938
    21827     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    21828       if test -n "$SAMPLE_CFLAGS" ; then
    21829         { echo "$as_me:$LINENO: Sample CFLAGS are $SAMPLE_CFLAGS" >&5
     21939  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     21940    if test -n "$SAMPLE_CFLAGS" ; then
     21941      { echo "$as_me:$LINENO: Sample CFLAGS are $SAMPLE_CFLAGS" >&5
    2183021942echo "$as_me: Sample CFLAGS are $SAMPLE_CFLAGS" >&6;}
    21831       fi
    21832       if test -n "$SAMPLE_LIBS" ; then
    21833         { echo "$as_me:$LINENO: Sample LIBS   are $SAMPLE_LIBS" >&5
     21943    fi
     21944    if test -n "$SAMPLE_LIBS" ; then
     21945      { echo "$as_me:$LINENO: Sample LIBS   are $SAMPLE_LIBS" >&5
    2183421946echo "$as_me: Sample LIBS   are $SAMPLE_LIBS" >&6;}
    21835       fi
    21836       if test -n "$SAMPLE_DATA" ; then
    21837         { echo "$as_me:$LINENO: Sample DATA   is  $SAMPLE_DATA" >&5
     21947    fi
     21948    if test -n "$SAMPLE_DATA" ; then
     21949      { echo "$as_me:$LINENO: Sample DATA   is  $SAMPLE_DATA" >&5
    2183821950echo "$as_me: Sample DATA   is  $SAMPLE_DATA" >&6;}
    21839       fi
    21840 
    2184121951    fi
     21952
    2184221953  fi
    21843 done
     21954
     21955fi
    2184421956
    2184521957
     
    2202922141# initial list of dependencies is "coindatanetlib", but we need to filter out version number specifications (= x, <= x, >= x)
    2203022142projtoprocess="coindatanetlib"
    22031 projprocessed=""
    22032 
    22033 while test $coin_has_netlib = notGiven ; do
    22034   # setup list of projects that need to be processed in the next round
    22035   nextprojtoprocess=""
     22143
     22144# we first expand the list of projects to process by adding all dependencies just behind the project which depends on it
     22145# further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards
     22146# also, we setup the DATA variable
     22147allproj=""
     22148allpcfiles=""
     22149while test "x$projtoprocess" != x ; do
    2203622150
    2203722151  for proj in $projtoprocess ; do
    22038     # if $proj has been processed already, skip this round
    22039     if test "x$projprocessed" != x ; then
    22040       for projdone in $projprocessed ; do
    22041         if test $projdone = $proj ; then
    22042           continue 2
    22043         fi
    22044       done
    22045     fi
    22046 
    2204722152    # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it
    2204822153    pcfile=""
     
    2205322158      if test -r "$dir/$proj-uninstalled.pc" ; then
    2205422159        pcfile="$dir/$proj-uninstalled.pc"
    22055         pcfiledir="$dir"
    2205622160        break
    2205722161      fi
     
    2206022164
    2206122165    if test "x$pcfile" != x ; then
    22062       # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
    22063       projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
    22064       projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
    22065       NETLIB_CFLAGS="$projcflags $NETLIB_CFLAGS"
    22066 
    22067       # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
    22068       # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
    22069       projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
    22070       if test "x$projlibs" != x ; then
    22071         if test -d "${pcfiledir}/src" ; then
    22072           projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
    22073         else
    22074           projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
    22075         fi
    22076       else
    22077         projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
    22078       fi
    22079       NETLIB_LIBS="$NETLIB_LIBS $projlibs"
     22166      # read dependencies from $pcfile and filter it
     22167      projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
     22168
     22169      # add projrequires to the front of the list of projects that have to be processed next
     22170      # at the same time, remove $proj from this list
     22171      projtoprocess=${projtoprocess/$proj/$projrequires}
    2208022172
    2208122173      # read DATA from $pcfile, if this is the first .pc file we are processing (so assume that its the main one)
    22082       if test "x$projprocessed" = x ; then
     22174      if test "x$allproj" = x ; then
    2208322175        NETLIB_DATA=`sed -n -e 's/datadir=//gp' "$pcfile"`
    2208422176      fi
    2208522177
    22086       # read dependencies from $pcfile, filter it, and add to list of projects that need to be processed next
    22087       projrequires=`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[        ]\{0,\}[^       ]\{1,\}//g'`
    22088       nextprojtoprocess="$nextprojtoprocess $projrequires"
    22089 
    22090       # remember that we have processed $proj
    22091       projprocessed="$projprocessed $proj"
     22178      allproj="$allproj $proj"
     22179      allpcfiles="$pcfile:$allpcfiles"
    2209222180
    2209322181    else
    2209422182      echo "$as_me:$LINENO: result: no, dependency $proj not available" >&5
    2209522183echo "${ECHO_T}no, dependency $proj not available" >&6
     22184      allproj=fail
    2209622185      break 2
    2209722186    fi
    2209822187
     22188    break
    2209922189  done
    2210022190
    22101   projtoprocess="$nextprojtoprocess"
    22102 
    22103   # if there are no more projects to search for, finish up
    22104   if test "x$projtoprocess" = x ; then
    22105     coin_has_netlib=yes
    22106     echo "$as_me:$LINENO: result: yes, dependencies are$projprocessed" >&5
    22107 echo "${ECHO_T}yes, dependencies are$projprocessed" >&6
     22191  # remove spaces on begin of $projtoprocess
     22192  projtoprocess=`echo $projtoprocess | sed -e 's/^ *//'`
     22193
     22194done
     22195
     22196if test "$allproj" != fail ; then
     22197
     22198  # now go through the list of .pc files and assemble compiler and linker flags
     22199  # important is here to obey the reverse order that has been setup before,
     22200  # since then libraries that are required by several others should be after these other libraries
     22201  pcfilesprocessed=""
     22202
     22203  save_IFS="$IFS"
     22204  IFS=":"
     22205  for pcfile in $allpcfiles ; do
     22206
     22207    # if $pcfile has been processed already, skip this round
     22208    if test "x$pcfilesprocessed" != x ; then
     22209      for pcfiledone in $pcfilesprocessed ; do
     22210        if test "$pcfiledone" = "$pcfile" ; then
     22211          continue 2
     22212        fi
     22213      done
     22214    fi
     22215
     22216    # reconstruct the directory where the .pc file is located
     22217    pcfiledir=`echo $pcfile | sed -e 's/\/[^\/]*$//'`
     22218
     22219    # read CFLAGS from $pcfile and add CYGPATH_W cludge into include flags
     22220    projcflags=`sed -n -e 's/Cflags://p' "$pcfile"`
     22221    projcflags=`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`
     22222    NETLIB_CFLAGS="$projcflags $NETLIB_CFLAGS"
     22223
     22224    # read LIBS from $pcfile and replace -L${libdir} by absolute path to build directory in linker flags
     22225    # we assume that the build directory is $pcfiledir/src if this directory exists, otherwise we assume that it is $pcfiledir
     22226    projlibs=`sed -n -e 's/Libs://' -e 's/-L\${libdir}//p' "$pcfile"`
     22227    if test "x$projlibs" != x ; then
     22228      if test -d "${pcfiledir}/src" ; then
     22229        projlibs="-L`cd "${pcfiledir}/src"; pwd` $projlibs"
     22230      else
     22231        projlibs="-L`cd "$pcfiledir"; pwd` $projlibs"
     22232      fi
     22233    else
     22234      projlibs=`sed -n -e 's/Libs://p' "$pcfile"`
     22235    fi
     22236    NETLIB_LIBS="$projlibs $NETLIB_LIBS"
     22237
     22238    # remember that we have processed $pcfile
     22239    pcfilesprocessed="$pcfilesprocessed:$pcfile"
     22240
     22241  done
     22242  IFS="$save_IFS"
     22243
     22244  # finish up
     22245  coin_has_netlib=yes
     22246  echo "$as_me:$LINENO: result: yes" >&5
     22247echo "${ECHO_T}yes" >&6
    2210822248
    2210922249cat >>confdefs.h <<\_ACEOF
     
    2211422254
    2211522255
    22116     if test 1 = 0 ; then  #change this test to enable a bit of debugging output
    22117       if test -n "$NETLIB_CFLAGS" ; then
    22118         { echo "$as_me:$LINENO: Netlib CFLAGS are $NETLIB_CFLAGS" >&5
     22256  if test 1 = 0 ; then  #change this test to enable a bit of debugging output
     22257    if test -n "$NETLIB_CFLAGS" ; then
     22258      { echo "$as_me:$LINENO: Netlib CFLAGS are $NETLIB_CFLAGS" >&5
    2211922259echo "$as_me: Netlib CFLAGS are $NETLIB_CFLAGS" >&6;}
    22120       fi
    22121       if test -n "$NETLIB_LIBS" ; then
    22122         { echo "$as_me:$LINENO: Netlib LIBS   are $NETLIB_LIBS" >&5
     22260    fi
     22261    if test -n "$NETLIB_LIBS" ; then
     22262      { echo "$as_me:$LINENO: Netlib LIBS   are $NETLIB_LIBS" >&5
    2212322263echo "$as_me: Netlib LIBS   are $NETLIB_LIBS" >&6;}
    22124       fi
    22125       if test -n "$NETLIB_DATA" ; then
    22126         { echo "$as_me:$LINENO: Netlib DATA   is  $NETLIB_DATA" >&5
     22264    fi
     22265    if test -n "$NETLIB_DATA" ; then
     22266      { echo "$as_me:$LINENO: Netlib DATA   is  $NETLIB_DATA" >&5
    2212722267echo "$as_me: Netlib DATA   is  $NETLIB_DATA" >&6;}
    22128       fi
    22129 
    2213022268    fi
     22269
    2213122270  fi
    22132 done
     22271
     22272fi
    2213322273
    2213422274
Note: See TracChangeset for help on using the changeset viewer.