1 | # Copyright (C) 2006, 2009 International Business Machines. |
---|
2 | # All Rights Reserved. |
---|
3 | # This file is distributed under the Eclipse Public License. |
---|
4 | # |
---|
5 | ## $Id: coin.m4 2553 2012-05-16 18:13:24Z stefan $ |
---|
6 | # |
---|
7 | # Author: Andreas Wachter IBM 2006-04-14 |
---|
8 | |
---|
9 | # This file defines the common autoconf macros for COIN |
---|
10 | # |
---|
11 | |
---|
12 | # Check requirements |
---|
13 | AC_PREREQ(2.59) |
---|
14 | |
---|
15 | ########################################################################### |
---|
16 | # coin_foreach_w # |
---|
17 | ########################################################################### |
---|
18 | |
---|
19 | # the autoconf version used by COIN-OR is so old that it does not have the M4 macro foreach_w. |
---|
20 | # thus, we define our own one which applies the foreach macro to the same arguments but with |
---|
21 | # all spaces replaced by ',' in the second argument. |
---|
22 | # further, we run the loop only if the second argument is not empty |
---|
23 | AC_DEFUN([coin_foreach_w], [m4_ifval([$2], [m4_foreach([$1], [m4_bpatsubsts([$2],[[ ]+],[, ])], [$3])])]) |
---|
24 | |
---|
25 | ########################################################################### |
---|
26 | # COIN_CHECK_FILE # |
---|
27 | ########################################################################### |
---|
28 | |
---|
29 | # A simple replacement for AC_CHECK_FILE that works for cross compilation |
---|
30 | |
---|
31 | AC_DEFUN([AC_COIN_CHECK_FILE], |
---|
32 | [if test -r $1; then |
---|
33 | $2 |
---|
34 | : |
---|
35 | else |
---|
36 | $3 |
---|
37 | : |
---|
38 | fi |
---|
39 | ]) |
---|
40 | |
---|
41 | ########################################################################### |
---|
42 | # COIN_CHECK_VPATH # |
---|
43 | ########################################################################### |
---|
44 | |
---|
45 | # This macro sets the variable coin_vpath_config to true if this is a |
---|
46 | # VPATH configuration, otherwise it sets it to false. |
---|
47 | |
---|
48 | AC_DEFUN([AC_COIN_CHECK_VPATH], |
---|
49 | [ |
---|
50 | AC_MSG_CHECKING(whether this is a VPATH configuration) |
---|
51 | if test `cd $srcdir; pwd` != `pwd`; then |
---|
52 | coin_vpath_config=yes; |
---|
53 | else |
---|
54 | coin_vpath_config=no; |
---|
55 | fi |
---|
56 | AC_MSG_RESULT($coin_vpath_config) |
---|
57 | ]) # AC_COIN_CHECK_VPATH |
---|
58 | |
---|
59 | ########################################################################### |
---|
60 | # COIN_PROJECTDIR_INIT # |
---|
61 | ########################################################################### |
---|
62 | |
---|
63 | # This macro does everything that is required in the early part in the |
---|
64 | # configure script, such as defining a few variables. This should only be used |
---|
65 | # in the main directory of a project directory (the one which holds the src |
---|
66 | # directory for the project). The first parameter is the project name. The |
---|
67 | # second (optional) is the libtool library version (important for releases, |
---|
68 | # less so for stable or trunk). |
---|
69 | |
---|
70 | AC_DEFUN([AC_COIN_PROJECTDIR_INIT], |
---|
71 | [ |
---|
72 | # As backup, we make sure we don't loose an FLIBS if it has been set |
---|
73 | # by the user |
---|
74 | save_FLIBS="$FLIBS" |
---|
75 | |
---|
76 | # A useful makefile conditional that is always false |
---|
77 | AM_CONDITIONAL(ALWAYS_FALSE, false) |
---|
78 | |
---|
79 | # We set the following variable so that we know later in AC_COIN_FINALIZE |
---|
80 | # that we are in a project main directory |
---|
81 | coin_projectdir=yes |
---|
82 | |
---|
83 | # Set the project's version numbers |
---|
84 | m4_ifvaln([$1],[ |
---|
85 | AC_DEFINE_UNQUOTED(m4_toupper($1_VERSION), ["$PACKAGE_VERSION"],[Version number of project]) |
---|
86 | |
---|
87 | [coin_majorver=`echo $PACKAGE_VERSION | sed -n -e 's/^\([0-9]*\).*/\1/gp'`] |
---|
88 | [coin_minorver=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.\([0-9]*\).*/\1/gp'`] |
---|
89 | [coin_releasever=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/gp'`] |
---|
90 | if test "x$coin_majorver" = x ; then coin_majorver=9999 ; fi |
---|
91 | if test "x$coin_minorver" = x ; then coin_minorver=9999 ; fi |
---|
92 | if test "x$coin_releasever" = x ; then coin_releasever=9999 ; fi |
---|
93 | AC_DEFINE_UNQUOTED(m4_toupper($1_VERSION_MAJOR), [$coin_majorver], [Major Version number of project]) |
---|
94 | AC_DEFINE_UNQUOTED(m4_toupper($1_VERSION_MINOR), [$coin_minorver], [Minor Version number of project]) |
---|
95 | AC_DEFINE_UNQUOTED(m4_toupper($1_VERSION_RELEASE), [$coin_releasever], [Release Version number of project]) |
---|
96 | |
---|
97 | # We use the following variable to have a string with the upper case |
---|
98 | # version of the project name |
---|
99 | COIN_PRJCT=m4_toupper($1) |
---|
100 | |
---|
101 | # Set the project's SVN revision number. The complicated sed expression |
---|
102 | # (made worse by quadrigraphs) ensures that things like 4123:4168MS end up |
---|
103 | # as a single number. |
---|
104 | AC_CHECK_PROG([have_svnversion],[svnversion],[yes],[no]) |
---|
105 | if test "x$have_svnversion" = xyes; then |
---|
106 | AC_SUBST(m4_toupper($1_SVN_REV)) |
---|
107 | svn_rev_tmp=`LANG=en_EN svnversion $srcdir 2>/dev/null` |
---|
108 | if test "x$svn_rev_tmp" != xexported -a "x$svn_rev_tmp" != x; then |
---|
109 | m4_toupper($1_SVN_REV)=`echo $svn_rev_tmp | sed -n -e 's/^@<:@0-9@:>@*://' -e 's/\(@<:@0-9@:>@\)@<:@^0-9@:>@*$/\1/p'` |
---|
110 | AC_DEFINE_UNQUOTED(m4_toupper($1_SVN_REV), $m4_toupper($1_SVN_REV), [SVN revision number of project]) |
---|
111 | fi |
---|
112 | fi |
---|
113 | ]) |
---|
114 | |
---|
115 | # Capture libtool library version, if given. |
---|
116 | m4_ifvaln([$2],[coin_libversion=$2],[]) |
---|
117 | |
---|
118 | ]) # AC_COIN_PROJECTDIR_INIT |
---|
119 | |
---|
120 | ########################################################################### |
---|
121 | # COIN_DEBUG_COMPILE # |
---|
122 | ########################################################################### |
---|
123 | |
---|
124 | # enable the configure flags --enable-debug and --enable-debug-prjct |
---|
125 | # (where prcjt is the name of the project in lower case) and set the |
---|
126 | # variable coin_debug_compile to true or false This is used by |
---|
127 | # COIN_PROG_CXX, COIN_PROG_CC and COIN_PROG_F77 to determine the |
---|
128 | # compilation flags. This macro also makes the switches |
---|
129 | # --with-prjct-verbosity and --with-prjct-checklevel available, which |
---|
130 | # define the preprocessor macros COIN_PRJCT_VERBOSITY and |
---|
131 | # COIN_PRJCT_CHECKLEVEL to the specified value (default is 0). |
---|
132 | # |
---|
133 | # The project specific flags are only made available, if one gives the |
---|
134 | # name of the project as first argument to this macro. |
---|
135 | |
---|
136 | AC_DEFUN([AC_COIN_DEBUG_COMPILE], |
---|
137 | [AC_BEFORE([$0],[AC_COIN_PROG_CXX])dnl |
---|
138 | AC_BEFORE([$0],[AC_COIN_PROG_CC])dnl |
---|
139 | AC_BEFORE([$0],[AC_COIN_PROG_F77])dnl |
---|
140 | |
---|
141 | AC_MSG_CHECKING([whether we want to compile in debug mode]) |
---|
142 | |
---|
143 | AC_ARG_ENABLE([debug], |
---|
144 | [AC_HELP_STRING([--enable-debug], |
---|
145 | [compile all projects with debug options tests (implies --disable-shared)])], |
---|
146 | [case "${enableval}" in |
---|
147 | yes) coin_debug_compile=true |
---|
148 | if test "${enable_shared+set}" = set; then :; else |
---|
149 | enable_shared=no |
---|
150 | fi |
---|
151 | ;; |
---|
152 | no) coin_debug_compile=false |
---|
153 | ;; |
---|
154 | *) AC_MSG_ERROR(bad value ${enableval} for --enable-debug) |
---|
155 | ;; |
---|
156 | esac], |
---|
157 | [coin_debug_compile=false]) |
---|
158 | |
---|
159 | m4_ifvaln([$1], |
---|
160 | [AC_ARG_ENABLE(debug-m4_tolower($1), |
---|
161 | [AC_HELP_STRING([--enable-debug-m4_tolower($1)], |
---|
162 | [compile project $1 with debug compiler flags])], |
---|
163 | [case "${enableval}" in |
---|
164 | yes) coin_debug_compile=true |
---|
165 | ;; |
---|
166 | no) coin_debug_compile=false |
---|
167 | ;; |
---|
168 | *) AC_MSG_ERROR(bad value ${enableval} for --enable-debug-m4_tolower($1)) |
---|
169 | ;; |
---|
170 | esac],[:]) |
---|
171 | ]) # m4_ifvaln([$1], |
---|
172 | |
---|
173 | if test $coin_debug_compile = true; then |
---|
174 | AC_MSG_RESULT([yes]) |
---|
175 | else |
---|
176 | AC_MSG_RESULT([no]) |
---|
177 | fi |
---|
178 | |
---|
179 | m4_ifvaln([$1], |
---|
180 | [AC_ARG_WITH(m4_tolower($1)-verbosity, |
---|
181 | AC_HELP_STRING([--with-m4_tolower($1)-verbosity], |
---|
182 | [specify the debug verbosity level for project $1]), |
---|
183 | [if test "$withval" = yes; then |
---|
184 | withval=1 |
---|
185 | fi |
---|
186 | m4_tolower(coin_$1_verbosity)=$withval], |
---|
187 | [m4_tolower(coin_$1_verbosity)=0]) |
---|
188 | AC_DEFINE_UNQUOTED(m4_toupper(COIN_$1_VERBOSITY), |
---|
189 | m4_tolower($coin_$1_verbosity), |
---|
190 | [Define to the debug verbosity level (0 is no output)]) |
---|
191 | |
---|
192 | AC_ARG_WITH(m4_tolower($1)-checklevel, |
---|
193 | AC_HELP_STRING([--with-m4_tolower($1)-checklevel], |
---|
194 | [specify the sanity check level for project $1]), |
---|
195 | [if test "$withval" = yes; then |
---|
196 | withval=1 |
---|
197 | fi |
---|
198 | m4_tolower(coin_$1_checklevel)=$withval], |
---|
199 | [m4_tolower(coin_$1_checklevel)=0]) |
---|
200 | AC_DEFINE_UNQUOTED(m4_toupper(COIN_$1_CHECKLEVEL), |
---|
201 | m4_tolower($coin_$1_checklevel), |
---|
202 | [Define to the debug sanity check level (0 is no test)]) |
---|
203 | ]) # m4_ifvaln([$1], |
---|
204 | |
---|
205 | ]) # AC_COIN_DEBUG_COMPILE |
---|
206 | |
---|
207 | ########################################################################### |
---|
208 | # COIN_PROG_CXX # |
---|
209 | ########################################################################### |
---|
210 | |
---|
211 | AC_DEFUN([AC_COIN_PROG_CXX], |
---|
212 | [AC_REQUIRE([AC_PROG_CXX]) |
---|
213 | |
---|
214 | # add automake conditional so we can recognize cl compiler in makefile |
---|
215 | coin_cxx_is_cl=false |
---|
216 | case "$CXX" in |
---|
217 | clang* ) ;; |
---|
218 | cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*) |
---|
219 | coin_cxx_is_cl=true |
---|
220 | ;; |
---|
221 | esac |
---|
222 | AM_CONDITIONAL(COIN_CXX_IS_CL, [test $coin_cxx_is_cl = true]) |
---|
223 | |
---|
224 | # add -DPROJECT_BUILD to signal compiler preprocessor which config header file to include |
---|
225 | if test x$COIN_PRJCT != x; then |
---|
226 | CXXFLAGS="$CXXFLAGS -D${COIN_PRJCT}_BUILD" |
---|
227 | fi |
---|
228 | |
---|
229 | AC_MSG_NOTICE([C++ compiler options are: $CXXFLAGS]) |
---|
230 | |
---|
231 | ]) # AC_COIN_PROG_CXX |
---|
232 | |
---|
233 | |
---|
234 | ########################################################################### |
---|
235 | # COIN_CHECK_HEADER # |
---|
236 | ########################################################################### |
---|
237 | |
---|
238 | AC_DEFUN([AC_COIN_CHECK_HEADER],[AC_CHECK_HEADERS([$1],[$2],[$3],[$4])]) |
---|
239 | |
---|
240 | ########################################################################### |
---|
241 | # COIN_CHECK_CXX_CHEADER # |
---|
242 | ########################################################################### |
---|
243 | |
---|
244 | # This macro checks for C header files that are used from C++. For a given |
---|
245 | # stub (e.g., math), it first checks if the C++ library (cmath) is available. |
---|
246 | # If it is, it defines HAVE_CMATH (or whatever the stub is). If it is not |
---|
247 | # available, it checks for the old C head (math.h) and defines HAVE_MATH_H |
---|
248 | # if that one exists. |
---|
249 | |
---|
250 | AC_DEFUN([AC_COIN_CHECK_CXX_CHEADER], |
---|
251 | [AC_LANG_PUSH(C++) |
---|
252 | AC_COIN_CHECK_HEADER([c$1],[$2],[$3],[$4]) |
---|
253 | if test "$ac_cv_header_c$1" != "yes"; then |
---|
254 | AC_COIN_CHECK_HEADER([$1.h],[$2],[$3],[$4]) |
---|
255 | fi |
---|
256 | AC_LANG_POP(C++) |
---|
257 | ]) # AC_COIN_CHECK_CXX_CHEADER |
---|
258 | |
---|
259 | ########################################################################### |
---|
260 | # COIN_PROG_CC # |
---|
261 | ########################################################################### |
---|
262 | |
---|
263 | AC_DEFUN([AC_COIN_PROG_CC], |
---|
264 | [AC_REQUIRE([AC_PROG_CC]) |
---|
265 | |
---|
266 | # add automake conditional so we can recognize cl compiler in makefile |
---|
267 | coin_cc_is_cl=false |
---|
268 | case "$CC" in |
---|
269 | clang* ) ;; |
---|
270 | cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*) |
---|
271 | coin_cc_is_cl=true |
---|
272 | ;; |
---|
273 | esac |
---|
274 | AM_CONDITIONAL(COIN_CC_IS_CL, [test $coin_cc_is_cl = true]) |
---|
275 | |
---|
276 | # add -DPROJECT_BUILD to signal compiler preprocessor which config header file to include |
---|
277 | if test x$COIN_PRJCT != x; then |
---|
278 | CFLAGS="$CFLAGS -D${COIN_PRJCT}_BUILD" |
---|
279 | fi |
---|
280 | |
---|
281 | AC_MSG_NOTICE([C compiler options are: $CFLAGS]) |
---|
282 | |
---|
283 | ]) # AC_COIN_PROG_CC |
---|
284 | |
---|
285 | ########################################################################### |
---|
286 | # COIN_PROG_F77 # |
---|
287 | ########################################################################### |
---|
288 | |
---|
289 | |
---|
290 | AC_DEFUN([AC_COIN_PROG_F77], |
---|
291 | [AC_REQUIRE([AC_PROG_F77]) |
---|
292 | |
---|
293 | AC_MSG_NOTICE([Fortran compiler options are: $FFLAGS]) |
---|
294 | |
---|
295 | ]) # AC_COIN_PROG_F77 |
---|
296 | |
---|
297 | ########################################################################### |
---|
298 | # COIN_F77_WRAPPERS # |
---|
299 | ########################################################################### |
---|
300 | |
---|
301 | AC_DEFUN([AC_COIN_F77_WRAPPERS],[AC_REQUIRE([AC_F77_WRAPPERS])]) |
---|
302 | |
---|
303 | ########################################################################### |
---|
304 | # COIN_INIT_AUTOMAKE # |
---|
305 | ########################################################################### |
---|
306 | |
---|
307 | # This macro calls the regular INIT_AUTOMAKE and MAINTAINER_MODE |
---|
308 | # macros, and defines additional variables and makefile conditionals, |
---|
309 | # that are used in the maintainer parts of the makfile. It also |
---|
310 | # checks if the correct versions of the autotools are used. |
---|
311 | # |
---|
312 | # This also defines the AC_SUBST variables: |
---|
313 | # abs_source_dir absolute path to source code for this package |
---|
314 | # abs_bin_dir absolute path to the directory where binaries are |
---|
315 | # going to be installed (prefix/bin) |
---|
316 | # abs_lib_dir absolute path to the directory where libraries are |
---|
317 | # going to be installed (prefix/lib) |
---|
318 | # abs_include_dir absolute path to the directory where the header files |
---|
319 | # are installed (prefix/include) |
---|
320 | |
---|
321 | AC_DEFUN([AC_COIN_INIT_AUTOMAKE], |
---|
322 | [AC_REQUIRE([AC_PROG_EGREP]) |
---|
323 | AC_REQUIRE([AC_PROG_LN_S]) |
---|
324 | |
---|
325 | # AC_MSG_NOTICE([Beginning automake initialisation.]) |
---|
326 | # Stuff for automake |
---|
327 | AM_INIT_AUTOMAKE |
---|
328 | AM_MAINTAINER_MODE |
---|
329 | |
---|
330 | coin_have_externals=no |
---|
331 | if test "$enable_maintainer_mode" = yes; then |
---|
332 | |
---|
333 | # If maintainer mode is chosen, we make sure that the correct versions |
---|
334 | # of the tools are used, and that we know where libtool.m4 is (to |
---|
335 | # recreate acinclude.m4) |
---|
336 | |
---|
337 | AC_SUBST(LIBTOOLM4) |
---|
338 | LIBTOOLM4= |
---|
339 | # Normally, $HOME |
---|
340 | AUTOTOOLS_DFLT=$HOME |
---|
341 | |
---|
342 | AC_CACHE_CHECK([whether we are using the correct autotools], |
---|
343 | [ac_cv_use_correct_autotools], |
---|
344 | [ac_cv_use_correct_autotools=check]) |
---|
345 | |
---|
346 | if test $ac_cv_use_correct_autotools = check; then |
---|
347 | ac_cv_use_correct_autotools=yes |
---|
348 | # Check if we have autoconf |
---|
349 | AC_CHECK_PROG([have_autoconf],[autoconf],[yes],[no]) |
---|
350 | if test $have_autoconf = no; then |
---|
351 | AC_MSG_ERROR([You specified you want to use maintainer mode, but I cannot find autoconf in your path.]) |
---|
352 | fi |
---|
353 | |
---|
354 | # Check whether autoconf is the correct version |
---|
355 | correct_version='2.69' |
---|
356 | grep_version=`echo $correct_version | sed -e 's/\\./\\\\\\./g'` |
---|
357 | AC_MSG_CHECKING([whether we are using the correct version ($correct_version) of autoconf]) |
---|
358 | autoconf --version > confauto.out 2>&1 |
---|
359 | if $EGREP $grep_version confauto.out >/dev/null 2>&1; then |
---|
360 | AC_MSG_RESULT([yes]) |
---|
361 | else |
---|
362 | rm -f confauto.out |
---|
363 | AC_MSG_RESULT([no]) |
---|
364 | AC_MSG_ERROR([You don't have the correct version of autoconf as the first one in your path.]) |
---|
365 | fi |
---|
366 | rm -f confauto.out |
---|
367 | |
---|
368 | # Check if the executable autoconf is picked up from the correct location |
---|
369 | AC_MSG_CHECKING([whether autoconf is coming from the correct location]) |
---|
370 | autoconf_dir=`which autoconf | sed -e 's=/autoconf=='` |
---|
371 | autoconf_dir=`cd $autoconf_dir; pwd` |
---|
372 | if test x$AUTOTOOLS_DIR = x; then |
---|
373 | want_dir=$AUTOTOOLS_DFLT/bin |
---|
374 | else |
---|
375 | want_dir=$AUTOTOOLS_DIR/bin |
---|
376 | fi |
---|
377 | if test $autoconf_dir = `cd $want_dir; pwd`; then |
---|
378 | AC_MSG_RESULT([yes]) |
---|
379 | else |
---|
380 | rm -f confauto.out |
---|
381 | AC_MSG_RESULT([no]) |
---|
382 | AC_MSG_ERROR([The autoconf executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin.]) |
---|
383 | fi |
---|
384 | |
---|
385 | # Check if we have automake |
---|
386 | AC_CHECK_PROG([have_automake],[automake],[yes],[no]) |
---|
387 | if test $have_automake = no; then |
---|
388 | AC_MSG_ERROR([You specified you want to use maintainer mode, but I cannot find automake in your path.]) |
---|
389 | fi |
---|
390 | |
---|
391 | # Check whether automake is the correct version |
---|
392 | correct_version='1.12' |
---|
393 | grep_version=`echo $correct_version | sed -e 's/\\./\\\\\\./g'` |
---|
394 | AC_MSG_CHECKING([whether we are using the correct version ($correct_version) of automake]) |
---|
395 | automake --version > confauto.out 2>&1 |
---|
396 | if $EGREP $grep_version confauto.out >/dev/null 2>&1; then |
---|
397 | AC_MSG_RESULT([yes]) |
---|
398 | else |
---|
399 | rm -f confauto.out |
---|
400 | AC_MSG_RESULT([no]) |
---|
401 | AC_MSG_ERROR([You don't have the correct version of automake as the first one in your path.]) |
---|
402 | fi |
---|
403 | rm -f confauto.out |
---|
404 | |
---|
405 | # Check if the executable automake is picked up from the correct location |
---|
406 | AC_MSG_CHECKING([whether automake is coming from the correct location]) |
---|
407 | automake_dir=`which automake | sed -e 's=/automake=='` |
---|
408 | automake_dir=`cd $automake_dir; pwd` |
---|
409 | if test x$AUTOTOOLS_DIR = x; then |
---|
410 | want_dir=$AUTOTOOLS_DFLT/bin |
---|
411 | else |
---|
412 | want_dir=$AUTOTOOLS_DIR/bin |
---|
413 | fi |
---|
414 | if test $automake_dir = `cd $want_dir; pwd`; then |
---|
415 | AC_MSG_RESULT([yes]) |
---|
416 | else |
---|
417 | rm -f confauto.out |
---|
418 | AC_MSG_RESULT([no]) |
---|
419 | AC_MSG_ERROR([The automake executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin.]) |
---|
420 | fi |
---|
421 | |
---|
422 | # Check if this is the correct version of libtool (with escaped dots) |
---|
423 | if test x$AUTOTOOLS_DIR = x; then |
---|
424 | want_dir=$AUTOTOOLS_DFLT/share |
---|
425 | else |
---|
426 | want_dir=$AUTOTOOLS_DIR/share |
---|
427 | fi |
---|
428 | correct_version='2.4.2' |
---|
429 | grep_version=`echo $correct_version | sed -e 's/\\./\\\\\\./g'` |
---|
430 | AC_COIN_CHECK_FILE([$want_dir/libtool/ltmain.sh], |
---|
431 | [have_ltmain=yes], |
---|
432 | [have_ltmain=no]) |
---|
433 | AC_MSG_CHECKING([whether we are using the correct version ($correct_version) of libtool.]) |
---|
434 | if test $have_ltmain = yes; then |
---|
435 | if $EGREP $grep_version $want_dir/libtool/ltmain.sh >/dev/null 2>&1; then |
---|
436 | AC_MSG_RESULT([yes]) |
---|
437 | else |
---|
438 | AC_MSG_RESULT([no]) |
---|
439 | AC_MSG_ERROR([You don't have the correct version of libtool.]) |
---|
440 | fi |
---|
441 | else |
---|
442 | AC_MSG_RESULT([no]) |
---|
443 | AC_MSG_ERROR([I cannot find the ltmain.sh file.]) |
---|
444 | fi |
---|
445 | fi |
---|
446 | |
---|
447 | # Check if we can find the libtool file |
---|
448 | if test x$AUTOTOOLS_DIR = x; then |
---|
449 | want_dir=$AUTOTOOLS_DFLT/share |
---|
450 | else |
---|
451 | want_dir=$AUTOTOOLS_DIR/share |
---|
452 | fi |
---|
453 | AC_COIN_CHECK_FILE([$want_dir/aclocal/libtool.m4], |
---|
454 | [LIBTOOLM4="$want_dir/aclocal/libtool.m4"], |
---|
455 | [AC_MSG_ERROR([I cannot find the libtool.m4 file.])]) |
---|
456 | |
---|
457 | # Check if we have an Dependencies file |
---|
458 | if test -r $srcdir/Dependencies; then |
---|
459 | coin_have_externals=yes |
---|
460 | fi |
---|
461 | # Check if subversion is installed and understands https |
---|
462 | AC_CHECK_PROG([have_svn],[svn],[yes],[no]) |
---|
463 | if test x$have_svn = xyes; then |
---|
464 | AC_CACHE_CHECK([whether svn understands https], |
---|
465 | [ac_cv_svn_understands_https], |
---|
466 | [svn --version > confauto.out 2>&1 |
---|
467 | if $EGREP https confauto.out >/dev/null 2>&1; then |
---|
468 | ac_cv_svn_understands_https=yes |
---|
469 | else |
---|
470 | ac_cv_svn_understands_https=no |
---|
471 | have_svn=no |
---|
472 | ac_cv_prog_have_svn=no |
---|
473 | fi |
---|
474 | rm -f confauto.out]) |
---|
475 | fi |
---|
476 | |
---|
477 | # Find the location of the BuildTools directory |
---|
478 | BUILDTOOLSDIR= |
---|
479 | if test -r $srcdir/BuildTools/coin.m4; then |
---|
480 | BUILDTOOLSDIR=$srcdir/BuildTools |
---|
481 | else |
---|
482 | if test -r $srcdir/../BuildTools/coin.m4; then |
---|
483 | BUILDTOOLSDIR=$srcdir/../BuildTools |
---|
484 | else |
---|
485 | if test -r $srcdir/../../BuildTools/coin.m4; then |
---|
486 | BUILDTOOLSDIR=$srcdir/../../BuildTools |
---|
487 | else |
---|
488 | AC_MSG_ERROR(Cannot find the BuildTools directory, better disable maintainer mode.) |
---|
489 | fi |
---|
490 | fi |
---|
491 | fi |
---|
492 | AC_SUBST(BUILDTOOLSDIR) |
---|
493 | |
---|
494 | # for running automake by make, we need to have Makemain.inc available at the place where it usually can be found during run_autotools |
---|
495 | if test "$BUILDTOOLSDIR" != "$srcdir/BuildTools" ; then |
---|
496 | $LN_S `cd $BUILDTOOLSDIR; pwd` "$srcdir/BuildTools" |
---|
497 | fi |
---|
498 | |
---|
499 | # The following variable is set to the name of the directory where |
---|
500 | # the autotool scripts are located |
---|
501 | AC_SUBST(AUX_DIR) |
---|
502 | AUX_DIR=$ac_aux_dir |
---|
503 | fi |
---|
504 | |
---|
505 | # helpful variable for the base directory of this package |
---|
506 | abs_source_dir=`cd $srcdir; pwd` |
---|
507 | AC_SUBST(abs_source_dir) |
---|
508 | |
---|
509 | # Stuff for example Makefiles |
---|
510 | if test x$prefix = xNONE; then |
---|
511 | full_prefix=$ac_default_prefix |
---|
512 | else |
---|
513 | full_prefix=$prefix |
---|
514 | fi |
---|
515 | full_prefix=`cd $full_prefix ; pwd` |
---|
516 | AC_SUBST(abs_lib_dir) |
---|
517 | abs_lib_dir=$full_prefix/lib |
---|
518 | AC_SUBST(abs_include_dir) |
---|
519 | abs_include_dir=$full_prefix/include |
---|
520 | AC_SUBST(abs_bin_dir) |
---|
521 | abs_bin_dir=$full_prefix/bin |
---|
522 | |
---|
523 | AM_CONDITIONAL(HAVE_EXTERNALS, |
---|
524 | test $coin_have_externals = yes && test x$have_svn = xyes) |
---|
525 | |
---|
526 | # AC_MSG_NOTICE([End automake initialisation.]) |
---|
527 | |
---|
528 | ]) # AC_COIN_INIT_AUTOMAKE |
---|
529 | |
---|
530 | ########################################################################### |
---|
531 | # COIN_CREATE_LIBTOOL # |
---|
532 | ########################################################################### |
---|
533 | |
---|
534 | # This does all the tests necessary to create the libtool script in the |
---|
535 | # package base directory. If this is used, then the COIN_INIT_AUTO_TOOLS |
---|
536 | # test in the subdirectories will be able to skip the libtool tests and |
---|
537 | # just use the one in the package base directory. |
---|
538 | |
---|
539 | m4_define([AC_COIN_CREATE_LIBTOOL], |
---|
540 | [AC_CANONICAL_BUILD |
---|
541 | |
---|
542 | # Check if user wants to produce debugging code |
---|
543 | AC_COIN_DEBUG_COMPILE |
---|
544 | |
---|
545 | # Get the name of the C compiler and appropriate compiler options |
---|
546 | AC_COIN_PROG_CC |
---|
547 | |
---|
548 | # Get the name of the C++ compiler and appropriate compiler options |
---|
549 | AC_COIN_PROG_CXX |
---|
550 | |
---|
551 | # Get the name of the Fortran compiler and appropriate compiler options |
---|
552 | AC_COIN_PROG_F77 |
---|
553 | |
---|
554 | # Initialize automake and libtool |
---|
555 | AC_COIN_INIT_AUTO_TOOLS |
---|
556 | ]) |
---|
557 | |
---|
558 | ########################################################################### |
---|
559 | # COIN_INIT_AUTO_TOOLS # |
---|
560 | ########################################################################### |
---|
561 | |
---|
562 | # Initialize the auto tools automake and libtool, with all |
---|
563 | # modifications we want for COIN packages. |
---|
564 | # |
---|
565 | # RPATH_FLAGS link flags for hardcoding path to shared objects |
---|
566 | |
---|
567 | m4_define([AC_COIN_INIT_AUTO_TOOLS], |
---|
568 | [{AC_BEFORE([AC_COIN_PROG_CXX],[$0]) |
---|
569 | AC_BEFORE([AC_COIN_PROG_CC],[$0]) |
---|
570 | AC_BEFORE([AC_COIN_PROG_F77],[$0]) |
---|
571 | |
---|
572 | # Initialize automake |
---|
573 | AC_COIN_INIT_AUTOMAKE |
---|
574 | |
---|
575 | LIBTOOL= |
---|
576 | if test -r ../libtool; then |
---|
577 | coin_config_dir=.. |
---|
578 | LIBTOOL='$(SHELL) $(top_builddir)/../libtool' |
---|
579 | fi |
---|
580 | if test "x$LIBTOOL" = x; then |
---|
581 | if test -r ../../libtool; then |
---|
582 | coin_config_dir=../.. |
---|
583 | LIBTOOL='$(SHELL) $(top_builddir)/../../libtool' |
---|
584 | fi |
---|
585 | fi |
---|
586 | |
---|
587 | # ToDo for now, do not reuse libtool script because code below may need some updates |
---|
588 | # e.g., getting the SED and ECHO variables |
---|
589 | LIBTOOL= |
---|
590 | |
---|
591 | if test "x$LIBTOOL" = x; then |
---|
592 | # Stuff for libtool |
---|
593 | AC_COIN_PROG_LIBTOOL |
---|
594 | # set RPATH_FLAGS to the compiler link flags required to hardcode location |
---|
595 | # of the shared objects |
---|
596 | AC_COIN_RPATH_FLAGS([$abs_lib_dir]) |
---|
597 | |
---|
598 | else |
---|
599 | |
---|
600 | AC_MSG_NOTICE([Using libtool script in directory $coin_config_dir]) |
---|
601 | # get all missing information from the config.log file |
---|
602 | |
---|
603 | # output variables and defines |
---|
604 | as_save_IFS=$IFS |
---|
605 | IFS=' |
---|
606 | ' |
---|
607 | for oneline in `cat $coin_config_dir/config.status`; do |
---|
608 | case "$oneline" in |
---|
609 | # First some automake conditionals |
---|
610 | s,@am__fastdep* | s,@AR@* | s,@CPP@* | s,@CPPFLAGS@* | s,@CXXCPP@* | \ |
---|
611 | s,@RANLIB@* | s,@STRIP@* | s,@ac_ct_AR@* | s,@ac_ct_RANLIB@* | \ |
---|
612 | s,@ac_ct_STRIP@* | s,@host* | s,@LN_S@* | s,@RPATH_FLAGS@* | \ |
---|
613 | s,@ac_c_preproc_warn_flag@* | s,@ac_cxx_preproc_warn_flag@* ) |
---|
614 | command=`echo $oneline | sed -e 's/^s,@//' -e 's/@,/="/' -e 's/,;t t/"/'` |
---|
615 | eval "$command" |
---|
616 | ;; |
---|
617 | s,@DEFS@* ) |
---|
618 | command=`echo $oneline | sed -e 's/^s,@DEFS@,/defsline="/' -e 's/,;t t/"/'` |
---|
619 | eval "$command" |
---|
620 | ;; |
---|
621 | esac |
---|
622 | done |
---|
623 | IFS=$as_save_IFS |
---|
624 | |
---|
625 | # And some defines (assuming here that the packages base dir doesn't have a config.h file) |
---|
626 | for word in $defsline; do |
---|
627 | case $word in |
---|
628 | -DHAVE_@<:@A-Z_@:>@*_H=1 | -DSTDC_HEADERS=1 ) |
---|
629 | i=`echo $word | sed -e 's/-D/#define /' -e 's/=/ /'` |
---|
630 | echo $i >>confdefs.h |
---|
631 | ;; |
---|
632 | esac |
---|
633 | done |
---|
634 | fi |
---|
635 | |
---|
636 | # ToDo |
---|
637 | # For now, don't use the -no-undefined flag, since the Makefiles are |
---|
638 | # not yet set up that way. But we need to fix this, when we want |
---|
639 | # to comile DLLs under Windows. |
---|
640 | LT_LDFLAGS= |
---|
641 | |
---|
642 | # Check if we want to set the library version |
---|
643 | AC_MSG_CHECKING([if library version is set]) |
---|
644 | if test x"$coin_libversion" != x; then |
---|
645 | LT_LDFLAGS="$LT_LDFLAGS -version-info $coin_libversion" |
---|
646 | AC_MSG_RESULT([$coin_libversion]) |
---|
647 | else |
---|
648 | AC_MSG_RESULT([no]) |
---|
649 | fi |
---|
650 | |
---|
651 | AC_SUBST(LT_LDFLAGS) |
---|
652 | |
---|
653 | }]) |
---|
654 | |
---|
655 | ########################################################################### |
---|
656 | # COIN_PROG_LIBTOOL # |
---|
657 | ########################################################################### |
---|
658 | |
---|
659 | # Setup the libtool stuff together with any modifications to make it |
---|
660 | # work on additional platforms. |
---|
661 | # If libtool exists in the directory higher up, we use that one |
---|
662 | # instead of creating a new one. |
---|
663 | |
---|
664 | AC_DEFUN([AC_COIN_PROG_LIBTOOL], |
---|
665 | [ |
---|
666 | # It turns out that the code for AC_PROG_LIBTOOL is somehow AC_REQUIRED |
---|
667 | # out in front of this macro body. You'll notice that LIBTOOL is already |
---|
668 | # defined here. We'll have to count on this macro not being called if libtool |
---|
669 | # already exists, or at least move the libtool fixes outside the conditional. |
---|
670 | # AC_MSG_NOTICE([Entering coin_prog_libtool, LIBTOOL = "$LIBTOOL".]) |
---|
671 | # This test is therefore removed. -- lh, 061214 -- |
---|
672 | # if test "x$LIBTOOL" = x; then |
---|
673 | |
---|
674 | # AC_MSG_NOTICE([Calling PROG_LIBTOOL.]) |
---|
675 | AC_PROG_LIBTOOL |
---|
676 | # AC_MSG_NOTICE([Finished PROG_LIBTOOL.]) |
---|
677 | AC_SUBST(ac_c_preproc_warn_flag) |
---|
678 | AC_SUBST(ac_cxx_preproc_warn_flag) |
---|
679 | |
---|
680 | AC_MSG_NOTICE([Build is "$build".]) |
---|
681 | mydos2unix='| dos2unix' |
---|
682 | case $build in |
---|
683 | *-mingw*) |
---|
684 | CYGPATH_W=echo |
---|
685 | mydos2unix= |
---|
686 | ;; |
---|
687 | esac |
---|
688 | |
---|
689 | # This fi matches the commented `if test "x$LIBTOOL" = x;' up at the head of |
---|
690 | # the macro. -- lh, 061214 -- |
---|
691 | # fi |
---|
692 | |
---|
693 | sed -e 's|tool_oldlib|oldlib|' \ |
---|
694 | libtool > conftest.bla |
---|
695 | mv conftest.bla libtool |
---|
696 | chmod 755 libtool |
---|
697 | |
---|
698 | # AC_MSG_NOTICE([End libtool initialisation.]) |
---|
699 | ]) # AC_COIN_PROG_LIBTOOL |
---|
700 | |
---|
701 | ########################################################################### |
---|
702 | # COIN_RPATH_FLAGS # |
---|
703 | ########################################################################### |
---|
704 | |
---|
705 | # This macro, in case shared objects are used, defines a variable |
---|
706 | # RPATH_FLAGS that can be used by the linker to hardwire the library |
---|
707 | # search path for the given directories. This is useful for example |
---|
708 | # Makefiles |
---|
709 | |
---|
710 | AC_DEFUN([AC_COIN_RPATH_FLAGS], |
---|
711 | [RPATH_FLAGS= |
---|
712 | |
---|
713 | if test $enable_shared = yes; then |
---|
714 | case $build in |
---|
715 | *-linux-*) |
---|
716 | if test "$GXX" = "yes"; then |
---|
717 | RPATH_FLAGS= |
---|
718 | for dir in $1; do |
---|
719 | RPATH_FLAGS="$RPATH_FLAGS -Wl,--rpath -Wl,$dir" |
---|
720 | done |
---|
721 | fi ;; |
---|
722 | *-darwin*) |
---|
723 | RPATH_FLAGS=nothing ;; |
---|
724 | *-ibm-*) |
---|
725 | case "$CXX" in |
---|
726 | xlC* | */xlC* | mpxlC* | */mpxlC*) |
---|
727 | RPATH_FLAGS=nothing ;; |
---|
728 | esac ;; |
---|
729 | *-hp-*) |
---|
730 | RPATH_FLAGS=nothing ;; |
---|
731 | *-mingw32) |
---|
732 | RPATH_FLAGS=nothing ;; |
---|
733 | *-*-solaris*) |
---|
734 | RPATH_FLAGS= |
---|
735 | for dir in $1; do |
---|
736 | RPATH_FLAGS="$RPATH_FLAGS -R$dir" |
---|
737 | done |
---|
738 | esac |
---|
739 | |
---|
740 | if test "$RPATH_FLAGS" = ""; then |
---|
741 | AC_MSG_WARN([Could not automatically determine how to tell the linker about automatic inclusion of the path for shared libraries. The test examples might not work if you link against shared objects. You will need to set the LD_LIBRARY_PATH, DYLP_LIBRARY_PATH, or LIBDIR variable manually.]) |
---|
742 | fi |
---|
743 | if test "$RPATH_FLAGS" = "nothing"; then |
---|
744 | RPATH_FLAGS= |
---|
745 | fi |
---|
746 | fi |
---|
747 | |
---|
748 | AC_SUBST(RPATH_FLAGS) |
---|
749 | ]) # AC_COIN_RPATH_FLAGS |
---|
750 | |
---|
751 | ########################################################################### |
---|
752 | # COIN_LINK_INPUT_CMD # |
---|
753 | ########################################################################### |
---|
754 | |
---|
755 | # This macro determines which command should be used to "link" files |
---|
756 | # that are input to the generated executables. On Windows, the codes |
---|
757 | # using the native Windows system libraries, cannot understand symbolic |
---|
758 | # links, and a copy should be used instead of 'ln -s'. |
---|
759 | # The result is stored in coin_link_input_cmd |
---|
760 | |
---|
761 | AC_DEFUN([AC_COIN_LINK_INPUT_CMD], |
---|
762 | [AC_REQUIRE([AC_PROG_LN_S]) |
---|
763 | AC_BEFORE([AC_COIN_PROG_CC], [$0]) |
---|
764 | AC_BEFORE([AC_COIN_ENABLE_DOSCOMPILE], [$0]) |
---|
765 | |
---|
766 | AC_MSG_CHECKING([which command should be used to link input files]) |
---|
767 | coin_link_input_cmd="$LN_S" |
---|
768 | if test "$enable_doscompile" = mingw; then |
---|
769 | coin_link_input_cmd=cp |
---|
770 | fi |
---|
771 | case "$CC" in |
---|
772 | clang* ) ;; |
---|
773 | cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*) |
---|
774 | coin_link_input_cmd=cp ;; |
---|
775 | esac |
---|
776 | AC_MSG_RESULT($coin_link_input_cmd) |
---|
777 | ]) |
---|
778 | |
---|
779 | ########################################################################### |
---|
780 | # COIN_FINALIZE # |
---|
781 | ########################################################################### |
---|
782 | |
---|
783 | # This macro should be called at the very end of the configure.ac file. |
---|
784 | # It creates the output files (by using AC_OUTPUT), and might do some other |
---|
785 | # things (such as generating links to data files in a VPATH configuration). |
---|
786 | # It also prints the "success" message. |
---|
787 | # Note: If the variable coin_skip_ac_output is set to yes, then no output |
---|
788 | # files are written. |
---|
789 | |
---|
790 | AC_DEFUN([AC_COIN_FINALIZE], |
---|
791 | [ |
---|
792 | AC_REQUIRE([AC_COIN_LINK_INPUT_CMD]) |
---|
793 | if test x$coin_skip_ac_output != xyes; then |
---|
794 | |
---|
795 | # Define VPATH_DISTCLEANFILES to be everything that needs to be |
---|
796 | # cleaned for distclean in a vpath configuration |
---|
797 | AC_SUBST(VPATH_DISTCLEANFILES) |
---|
798 | VPATH_DISTCLEANFILES="$coin_vpath_link_files" |
---|
799 | |
---|
800 | # Take out subdirectories if their configuration concluded that they |
---|
801 | # don't need to be compiled |
---|
802 | if test x"$coin_ac_skip_subdirs" != x; then |
---|
803 | new_subdirs= |
---|
804 | for i in $subdirs; do |
---|
805 | skipme=no |
---|
806 | for j in $coin_ac_skip_subdirs; do |
---|
807 | if test $i = $j; then |
---|
808 | skipme=yes; |
---|
809 | fi |
---|
810 | done |
---|
811 | if test $skipme = no; then |
---|
812 | new_subdirs="$new_subdirs $i" |
---|
813 | fi |
---|
814 | done |
---|
815 | subdirs="$new_subdirs" |
---|
816 | fi |
---|
817 | |
---|
818 | # need to come before AC_OUTPUT |
---|
819 | if test x$coin_projectdir != xyes; then |
---|
820 | # write coin_subdirs to a file so that project configuration knows where to find uninstalled projects |
---|
821 | echo $coin_subdirs > coin_subdirs.txt |
---|
822 | else |
---|
823 | # substitute for OBJDIR, needed to setup .pc file for uninstalled project |
---|
824 | ABSBUILDDIR="`pwd`" |
---|
825 | AC_SUBST(ABSBUILDDIR) |
---|
826 | fi |
---|
827 | |
---|
828 | AC_OUTPUT |
---|
829 | |
---|
830 | if test x"$coin_vpath_link_files" = x; then : ; else |
---|
831 | lnkcmd="$coin_link_input_cmd" |
---|
832 | if test "$lnkcmd" = cp; then |
---|
833 | AC_MSG_NOTICE(Copying data files for VPATH configuration) |
---|
834 | else |
---|
835 | AC_MSG_NOTICE(Creating VPATH links for data files) |
---|
836 | fi |
---|
837 | for file in $coin_vpath_link_files; do |
---|
838 | dir=`AS_DIRNAME(["./$file"])` |
---|
839 | if test -d $dir; then : ; else |
---|
840 | AS_MKDIR_P($dir) |
---|
841 | fi |
---|
842 | rm -f $file |
---|
843 | $lnkcmd $abs_source_dir/$file $file |
---|
844 | done |
---|
845 | fi |
---|
846 | |
---|
847 | AC_MSG_NOTICE([In case of trouble, first consult the troubleshooting page at https://projects.coin-or.org/BuildTools/wiki/user-troubleshooting]) |
---|
848 | if test x$coin_projectdir = xyes; then |
---|
849 | AC_MSG_NOTICE([Configuration of $PACKAGE_NAME successful]) |
---|
850 | else |
---|
851 | AC_MSG_NOTICE([Main configuration of $PACKAGE_NAME successful]) |
---|
852 | fi |
---|
853 | else |
---|
854 | AC_MSG_NOTICE([No configuration of $PACKAGE_NAME necessary]) |
---|
855 | fi |
---|
856 | |
---|
857 | ]) #AC_COIN_FINALIZE |
---|
858 | |
---|
859 | ########################################################################### |
---|
860 | # COIN_VPATH_LINK # |
---|
861 | ########################################################################### |
---|
862 | |
---|
863 | # This macro queues source files that need to be available in the build |
---|
864 | # directory. In a VPATH configuration, the files will be made available by |
---|
865 | # symbolic link or copy (when the platform does not support links). The list |
---|
866 | # is processed by COIN_FINALIZE. The parameter is a whitespace-separated |
---|
867 | # list of files. |
---|
868 | |
---|
869 | AC_DEFUN([AC_COIN_VPATH_LINK], |
---|
870 | [ |
---|
871 | AC_REQUIRE([AC_COIN_CHECK_VPATH]) |
---|
872 | # Allow for newlines in the parameter |
---|
873 | if test $coin_vpath_config = yes; then |
---|
874 | cvl_tmp="$1" |
---|
875 | for file in $cvl_tmp ; do |
---|
876 | coin_vpath_link_files="$coin_vpath_link_files $file" |
---|
877 | done |
---|
878 | fi |
---|
879 | ]) #AC_COIN_VPATH_LINK |
---|
880 | |
---|
881 | ########################################################################### |
---|
882 | # COIN_ENABLE_GNU_PACKAGES # |
---|
883 | ########################################################################### |
---|
884 | |
---|
885 | # This macro defined the --enable-gnu-packages flag. This can be used |
---|
886 | # to check if a user wants to compile GNU packges (such as readline) |
---|
887 | # into the executable. By default, GNU packages are disabled. |
---|
888 | # This also defines the automake conditional COIN_ENABLE_GNU_PACKAGES |
---|
889 | |
---|
890 | AC_DEFUN([AC_COIN_ENABLE_GNU_PACKAGES], |
---|
891 | [AC_ARG_ENABLE([gnu-packages], |
---|
892 | [AC_HELP_STRING([--enable-gnu-packages], |
---|
893 | [compile with GNU packages (disabled by default)])], |
---|
894 | [coin_enable_gnu=$enableval], |
---|
895 | [coin_enable_gnu=no]) |
---|
896 | ]) # AC_COIN_ENABLE_GNU_PACKAGES |
---|
897 | |
---|
898 | ####################################################################### |
---|
899 | # COIN_CHECK_LIBM # |
---|
900 | ####################################################################### |
---|
901 | |
---|
902 | # For a (space separated) list of arguments X, this macro adds the flags |
---|
903 | # for linking against the math library to a X_LIBS and X_PCLIBS. |
---|
904 | |
---|
905 | AC_DEFUN([AC_COIN_CHECK_LIBM], |
---|
906 | [AC_BEFORE([AC_COIN_PROG_CC],[$0]) |
---|
907 | |
---|
908 | if test x$coin_cxx_is_cl != xtrue && test x$coin_cc_is_cl != xtrue ; then |
---|
909 | coin_foreach_w([myvar], [$1], [ |
---|
910 | m4_toupper(myvar)_LIBS="-lm $m4_toupper(myvar)_LIBS" |
---|
911 | m4_toupper(myvar)_PCLIBS="-lm $m4_toupper(myvar)_PCLIBS" |
---|
912 | m4_toupper(myvar)_LIBS_INSTALLED="-lm $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
913 | ]) |
---|
914 | fi |
---|
915 | |
---|
916 | ]) # AC_COIN_CHECK_LIBM |
---|
917 | |
---|
918 | ########################################################################### |
---|
919 | # COIN_CHECK_GNU_ZLIB # |
---|
920 | ########################################################################### |
---|
921 | |
---|
922 | # This macro checks for the libz library. If found, it sets the automake |
---|
923 | # conditional COIN_HAS_ZLIB and defines the C preprocessor variable |
---|
924 | # COIN_HAS_ZLIB. Further, for a (space separated) list of arguments X, |
---|
925 | # it adds the linker flag to the variables X_LIBS, X_PCLIBS, and X_LIBS_INSTALLED. |
---|
926 | |
---|
927 | # TODO the macro name should be changed to AC_COIN_CHECK_ZLIB |
---|
928 | |
---|
929 | AC_DEFUN([AC_COIN_CHECK_GNU_ZLIB], |
---|
930 | [ |
---|
931 | AC_BEFORE([AC_COIN_PROG_CXX],[$0]) |
---|
932 | AC_BEFORE([AC_COIN_PROG_CC],[$0]) |
---|
933 | AC_BEFORE([AC_COIN_PROG_F77],[$0]) |
---|
934 | AC_BEFORE([$0],[AC_COIN_FINALIZE]) |
---|
935 | |
---|
936 | coin_has_zlib=no |
---|
937 | |
---|
938 | AC_ARG_ENABLE([zlib], |
---|
939 | [AC_HELP_STRING([--disable-zlib],[do not compile with compression library zlib])], |
---|
940 | [coin_enable_zlib=$enableval], |
---|
941 | [coin_enable_zlib=yes]) |
---|
942 | |
---|
943 | if test $coin_enable_zlib = yes; then |
---|
944 | AC_COIN_CHECK_HEADER([zlib.h],[coin_has_zlib=yes]) |
---|
945 | |
---|
946 | if test $coin_has_zlib = yes; then |
---|
947 | AC_CHECK_LIB([z],[gzopen],[:],[coin_has_zlib=no]) |
---|
948 | fi |
---|
949 | |
---|
950 | if test $coin_has_zlib = yes; then |
---|
951 | coin_foreach_w([myvar], [$1], [ |
---|
952 | m4_toupper(myvar)_LIBS="-lz $m4_toupper(myvar)_LIBS" |
---|
953 | m4_toupper(myvar)_PCLIBS="-lz $m4_toupper(myvar)_PCLIBS" |
---|
954 | m4_toupper(myvar)_LIBS_INSTALLED="-lz $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
955 | ]) |
---|
956 | AC_DEFINE([COIN_HAS_ZLIB],[1],[Define to 1 if zlib is available]) |
---|
957 | fi |
---|
958 | fi |
---|
959 | |
---|
960 | AM_CONDITIONAL(COIN_HAS_ZLIB,test x$coin_has_zlib = xyes) |
---|
961 | ]) # AC_COIN_CHECK_GNU_ZLIB |
---|
962 | |
---|
963 | |
---|
964 | ########################################################################### |
---|
965 | # COIN_CHECK_GNU_BZLIB # |
---|
966 | ########################################################################### |
---|
967 | |
---|
968 | # This macro checks for the libbz2 library. If found, it defines the C |
---|
969 | # preprocessor variable COIN_HAS_BZLIB. Further, for a (space separated) list |
---|
970 | # of arguments X, it adds the linker flag to the variables X_LIBS, X_PCLIBS, and X_LIBS_INSTALLED. |
---|
971 | |
---|
972 | # TODO the macro name should be changed to AC_COIN_CHECK_BZLIB |
---|
973 | |
---|
974 | AC_DEFUN([AC_COIN_CHECK_GNU_BZLIB], |
---|
975 | [ |
---|
976 | AC_BEFORE([AC_COIN_PROG_CXX],[$0]) |
---|
977 | AC_BEFORE([AC_COIN_PROG_CC],[$0]) |
---|
978 | AC_BEFORE([AC_COIN_PROG_F77],[$0]) |
---|
979 | AC_BEFORE([$0],[AC_COIN_FINALIZE]) |
---|
980 | |
---|
981 | AC_ARG_ENABLE([bzlib], |
---|
982 | [AC_HELP_STRING([--disable-bzlib],[do not compile with compression library bzlib])], |
---|
983 | [coin_enable_bzlib=$enableval], |
---|
984 | [coin_enable_bzlib=yes]) |
---|
985 | |
---|
986 | coin_has_bzlib=no |
---|
987 | if test $coin_enable_bzlib = yes; then |
---|
988 | AC_COIN_CHECK_HEADER([bzlib.h],[coin_has_bzlib=yes]) |
---|
989 | |
---|
990 | if test $coin_has_bzlib = yes; then |
---|
991 | AC_CHECK_LIB([bz2],[BZ2_bzReadOpen],[:],[coin_has_bzlib=no]) |
---|
992 | fi |
---|
993 | |
---|
994 | if test $coin_has_bzlib = yes; then |
---|
995 | coin_foreach_w([myvar], [$1], [ |
---|
996 | m4_toupper(myvar)_LIBS="-lbz2 $m4_toupper(myvar)_LIBS" |
---|
997 | m4_toupper(myvar)_PCLIBS="-lbz2 $m4_toupper(myvar)_PCLIBS" |
---|
998 | m4_toupper(myvar)_LIBS_INSTALLED="-lbz2 $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
999 | ]) |
---|
1000 | AC_DEFINE([COIN_HAS_BZLIB],[1],[Define to 1 if bzlib is available]) |
---|
1001 | fi |
---|
1002 | fi |
---|
1003 | ]) # AC_COIN_CHECK_GNU_BZLIB |
---|
1004 | |
---|
1005 | |
---|
1006 | ########################################################################### |
---|
1007 | # COIN_CHECK_GNU_READLINE # |
---|
1008 | ########################################################################### |
---|
1009 | |
---|
1010 | # This macro checks for GNU's readline. It verifies that the header |
---|
1011 | # readline/readline.h is available, and that the -lreadline library |
---|
1012 | # contains "readline". It is assumed that #include <stdio.h> is included |
---|
1013 | # in the source file before the #include<readline/readline.h> |
---|
1014 | # If found, it defines the C preprocessor variable COIN_HAS_READLINE. |
---|
1015 | # Further, for a (space separated) list of arguments X, it adds the |
---|
1016 | # linker flag to the variable X_LIBS, X_PCLIBS, and X_LIBS_INSTALLED. |
---|
1017 | |
---|
1018 | AC_DEFUN([AC_COIN_CHECK_GNU_READLINE], |
---|
1019 | [AC_REQUIRE([AC_COIN_ENABLE_GNU_PACKAGES]) |
---|
1020 | AC_BEFORE([AC_COIN_PROG_CXX],[$0]) |
---|
1021 | AC_BEFORE([AC_COIN_PROG_CC],[$0]) |
---|
1022 | AC_BEFORE([AC_COIN_PROG_F77],[$0]) |
---|
1023 | AC_BEFORE([$0],[AC_COIN_FINALIZE]) |
---|
1024 | |
---|
1025 | coin_has_readline=no |
---|
1026 | if test $coin_enable_gnu = yes; then |
---|
1027 | AC_COIN_CHECK_HEADER([readline/readline.h], |
---|
1028 | [coin_has_readline=yes],[], |
---|
1029 | [#include <stdio.h>]) |
---|
1030 | |
---|
1031 | coin_save_LIBS="$LIBS" |
---|
1032 | LIBS= |
---|
1033 | # First we check if tputs and friends are available |
---|
1034 | if test $coin_has_readline = yes; then |
---|
1035 | AC_SEARCH_LIBS([tputs],[ncurses termcap curses],[], |
---|
1036 | [coin_has_readline=no]) |
---|
1037 | fi |
---|
1038 | |
---|
1039 | # Now we check for readline |
---|
1040 | if test $coin_has_readline = yes; then |
---|
1041 | AC_CHECK_LIB([readline],[readline],[:],[coin_has_readline=no]) |
---|
1042 | fi |
---|
1043 | |
---|
1044 | if test $coin_has_readline = yes; then |
---|
1045 | coin_foreach_w([myvar], [$1], [ |
---|
1046 | m4_toupper(myvar)_LIBS="-lreadline $LIBS $m4_toupper(myvar)_LIBS" |
---|
1047 | m4_toupper(myvar)_PCLIBS="-lreadline $LIBS $m4_toupper(myvar)_PCLIBS" |
---|
1048 | m4_toupper(myvar)_LIBS_INSTALLED="-lreadline $LIBS $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
1049 | ]) |
---|
1050 | AC_DEFINE([COIN_HAS_READLINE],[1],[Define to 1 if readline is available]) |
---|
1051 | fi |
---|
1052 | |
---|
1053 | LIBS="$coin_save_LIBS" |
---|
1054 | fi |
---|
1055 | ]) # AC_COIN_CHECK_GNU_READLINE |
---|
1056 | |
---|
1057 | ########################################################################### |
---|
1058 | # COIN_CHECK_GMP # |
---|
1059 | ########################################################################### |
---|
1060 | |
---|
1061 | # This macro checks for the gmp library. If found, it defines the C |
---|
1062 | # preprocessor variable COIN_HAS_GMP. Further, for a (space separated) list |
---|
1063 | # of arguments X, it adds the linker flag to the variables X_LIBS, X_PCLIBS, and X_LIBS_INSTALLED. |
---|
1064 | |
---|
1065 | AC_DEFUN([AC_COIN_CHECK_GMP], |
---|
1066 | [ |
---|
1067 | AC_BEFORE([AC_COIN_PROG_CXX],[$0]) |
---|
1068 | AC_BEFORE([AC_COIN_PROG_CC],[$0]) |
---|
1069 | AC_BEFORE([AC_COIN_PROG_F77],[$0]) |
---|
1070 | AC_BEFORE([$0],[AC_COIN_FINALIZE]) |
---|
1071 | |
---|
1072 | AC_ARG_ENABLE([gmp], |
---|
1073 | [AC_HELP_STRING([--disable-gmp],[do not compile with GNU multiple precision library])], |
---|
1074 | [coin_enable_gmp=$enableval], |
---|
1075 | [coin_enable_gmp=yes]) |
---|
1076 | |
---|
1077 | coin_has_gmp=no |
---|
1078 | if test $coin_enable_gmp = yes; then |
---|
1079 | AC_COIN_CHECK_HEADER([gmp.h],[AC_CHECK_LIB([gmp],[__gmpz_init],[coin_has_gmp=yes])]) |
---|
1080 | |
---|
1081 | if test $coin_has_gmp = yes ; then |
---|
1082 | coin_foreach_w([myvar], [$1], [ |
---|
1083 | m4_toupper(myvar)_LIBS="-lgmp $m4_toupper(myvar)_LIBS" |
---|
1084 | m4_toupper(myvar)_PCLIBS="-lgmp $m4_toupper(myvar)_PCLIBS" |
---|
1085 | m4_toupper(myvar)_LIBS_INSTALLED="-lgmp $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
1086 | ]) |
---|
1087 | AC_DEFINE([COIN_HAS_GMP],[1],[Define to 1 if GMP is available]) |
---|
1088 | fi |
---|
1089 | fi |
---|
1090 | ]) # AC_COIN_CHECK_GMP |
---|
1091 | |
---|
1092 | ########################################################################### |
---|
1093 | # COIN_CHECK_ISFINITE # |
---|
1094 | ########################################################################### |
---|
1095 | |
---|
1096 | # This macro checks for a usable implementation of a function to check |
---|
1097 | # whether a given floating point number is finite. |
---|
1098 | # If a function is found, then the macro defines the symbol |
---|
1099 | # toupper($1)_C_FINITE to the name of this function. |
---|
1100 | |
---|
1101 | AC_DEFUN([AC_COIN_CHECK_ISFINITE],[ |
---|
1102 | |
---|
1103 | AC_LANG_PUSH(C++) |
---|
1104 | |
---|
1105 | AC_COIN_CHECK_CXX_CHEADER(math) |
---|
1106 | AC_COIN_CHECK_CXX_CHEADER(float) |
---|
1107 | AC_COIN_CHECK_CXX_CHEADER(ieeefp) |
---|
1108 | |
---|
1109 | COIN_C_FINITE= |
---|
1110 | AC_CHECK_DECL([isfinite],[COIN_C_FINITE=isfinite],,[ |
---|
1111 | #ifdef HAVE_CMATH |
---|
1112 | # include <cmath> |
---|
1113 | #else |
---|
1114 | # ifdef HAVE_MATH_H |
---|
1115 | # include <math.h> |
---|
1116 | # endif |
---|
1117 | #endif |
---|
1118 | #ifdef HAVE_CFLOAT |
---|
1119 | # include <cfloat> |
---|
1120 | #else |
---|
1121 | # ifdef HAVE_FLOAT_H |
---|
1122 | # include <float.h> |
---|
1123 | # endif |
---|
1124 | #endif |
---|
1125 | #ifdef HAVE_CIEEEFP |
---|
1126 | # include <cieeefp> |
---|
1127 | #else |
---|
1128 | # ifdef HAVE_IEEEFP_H |
---|
1129 | # include <ieeefp.h> |
---|
1130 | # endif |
---|
1131 | #endif]) |
---|
1132 | if test -z "$COIN_C_FINITE"; then |
---|
1133 | AC_CHECK_DECL([finite],[COIN_C_FINITE=finite],,[ |
---|
1134 | #ifdef HAVE_CMATH |
---|
1135 | # include <cmath> |
---|
1136 | #else |
---|
1137 | # ifdef HAVE_MATH_H |
---|
1138 | # include <math.h> |
---|
1139 | # endif |
---|
1140 | #endif |
---|
1141 | #ifdef HAVE_CFLOAT |
---|
1142 | # include <cfloat> |
---|
1143 | #else |
---|
1144 | # ifdef HAVE_FLOAT_H |
---|
1145 | # include <float.h> |
---|
1146 | # endif |
---|
1147 | #endif |
---|
1148 | #ifdef HAVE_CIEEEFP |
---|
1149 | # include <cieeefp> |
---|
1150 | #else |
---|
1151 | # ifdef HAVE_IEEEFP_H |
---|
1152 | # include <ieeefp.h> |
---|
1153 | # endif |
---|
1154 | #endif]) |
---|
1155 | if test -z "$COIN_C_FINITE"; then |
---|
1156 | AC_CHECK_DECL([_finite],[COIN_C_FINITE=_finite],,[ |
---|
1157 | #ifdef HAVE_CMATH |
---|
1158 | # include <cmath> |
---|
1159 | #else |
---|
1160 | # ifdef HAVE_MATH_H |
---|
1161 | # include <math.h> |
---|
1162 | # endif |
---|
1163 | #endif |
---|
1164 | #ifdef HAVE_CFLOAT |
---|
1165 | # include <cfloat> |
---|
1166 | #else |
---|
1167 | # ifdef HAVE_FLOAT_H |
---|
1168 | # include <float.h> |
---|
1169 | # endif |
---|
1170 | #endif |
---|
1171 | #ifdef HAVE_CIEEEFP |
---|
1172 | # include <cieeefp> |
---|
1173 | #else |
---|
1174 | # ifdef HAVE_IEEEFP_H |
---|
1175 | # include <ieeefp.h> |
---|
1176 | # endif |
---|
1177 | #endif]) |
---|
1178 | fi |
---|
1179 | fi |
---|
1180 | if test -z "$COIN_C_FINITE"; then |
---|
1181 | AC_MSG_WARN(Cannot find C-function for checking Inf.) |
---|
1182 | else |
---|
1183 | AC_DEFINE_UNQUOTED(COIN_C_FINITE,[$COIN_C_FINITE], |
---|
1184 | [Define to be the name of C-function for Inf check]) |
---|
1185 | fi |
---|
1186 | |
---|
1187 | AC_LANG_POP(C++) |
---|
1188 | ]) |
---|
1189 | |
---|
1190 | ########################################################################### |
---|
1191 | # COIN_CHECK_ISNAN # |
---|
1192 | ########################################################################### |
---|
1193 | |
---|
1194 | # This macro checks for a usable implementation of a function to check |
---|
1195 | # whether a given floating point number represents NaN. |
---|
1196 | # If a function is found, then the macro defines the symbol COIN_C_ISNAN |
---|
1197 | # to the name of this function. |
---|
1198 | |
---|
1199 | AC_DEFUN([AC_COIN_CHECK_ISNAN],[ |
---|
1200 | |
---|
1201 | AC_LANG_PUSH(C++) |
---|
1202 | |
---|
1203 | AC_COIN_CHECK_CXX_CHEADER(math) |
---|
1204 | AC_COIN_CHECK_CXX_CHEADER(float) |
---|
1205 | AC_COIN_CHECK_CXX_CHEADER(ieeefp) |
---|
1206 | |
---|
1207 | COIN_C_ISNAN= |
---|
1208 | AC_CHECK_DECL([isnan],[COIN_C_ISNAN=isnan],,[ |
---|
1209 | #ifdef HAVE_CMATH |
---|
1210 | # include <cmath> |
---|
1211 | #else |
---|
1212 | # ifdef HAVE_MATH_H |
---|
1213 | # include <math.h> |
---|
1214 | # endif |
---|
1215 | #endif |
---|
1216 | #ifdef HAVE_CFLOAT |
---|
1217 | # include <cfloat> |
---|
1218 | #else |
---|
1219 | # ifdef HAVE_FLOAT_H |
---|
1220 | # include <float.h> |
---|
1221 | # endif |
---|
1222 | #endif |
---|
1223 | #ifdef HAVE_CIEEEFP |
---|
1224 | # include <cieeefp> |
---|
1225 | #else |
---|
1226 | # ifdef HAVE_IEEEFP_H |
---|
1227 | # include <ieeefp.h> |
---|
1228 | # endif |
---|
1229 | #endif]) |
---|
1230 | |
---|
1231 | # It appears that for some systems (e.g., Mac OSX), cmath will provide only |
---|
1232 | # std::isnan, and bare isnan will be unavailable. Typically we need a parameter |
---|
1233 | # in the test to allow C++ to do overload resolution. |
---|
1234 | |
---|
1235 | if test -z "$COIN_C_ISNAN"; then |
---|
1236 | AC_CHECK_DECL([std::isnan(42.42)],[COIN_C_ISNAN=std::isnan],,[ |
---|
1237 | #ifdef HAVE_CMATH |
---|
1238 | # include <cmath> |
---|
1239 | #else |
---|
1240 | # ifdef HAVE_MATH_H |
---|
1241 | # include <math.h> |
---|
1242 | # endif |
---|
1243 | #endif |
---|
1244 | #ifdef HAVE_CFLOAT |
---|
1245 | # include <cfloat> |
---|
1246 | #else |
---|
1247 | # ifdef HAVE_FLOAT_H |
---|
1248 | # include <float.h> |
---|
1249 | # endif |
---|
1250 | #endif |
---|
1251 | #ifdef HAVE_CIEEEFP |
---|
1252 | # include <cieeefp> |
---|
1253 | #else |
---|
1254 | # ifdef HAVE_IEEEFP_H |
---|
1255 | # include <ieeefp.h> |
---|
1256 | # endif |
---|
1257 | #endif]) |
---|
1258 | fi |
---|
1259 | |
---|
1260 | if test -z "$COIN_C_ISNAN"; then |
---|
1261 | AC_CHECK_DECL([_isnan],[COIN_C_ISNAN=_isnan],,[ |
---|
1262 | #ifdef HAVE_CMATH |
---|
1263 | # include <cmath> |
---|
1264 | #else |
---|
1265 | # ifdef HAVE_MATH_H |
---|
1266 | # include <math.h> |
---|
1267 | # endif |
---|
1268 | #endif |
---|
1269 | #ifdef HAVE_CFLOAT |
---|
1270 | # include <cfloat> |
---|
1271 | #else |
---|
1272 | # ifdef HAVE_FLOAT_H |
---|
1273 | # include <float.h> |
---|
1274 | # endif |
---|
1275 | #endif |
---|
1276 | #ifdef HAVE_CIEEEFP |
---|
1277 | # include <cieeefp> |
---|
1278 | #else |
---|
1279 | # ifdef HAVE_IEEEFP_H |
---|
1280 | # include <ieeefp.h> |
---|
1281 | # endif |
---|
1282 | #endif]) |
---|
1283 | fi |
---|
1284 | if test -z "$COIN_C_ISNAN"; then |
---|
1285 | AC_CHECK_DECL([isnand],[COIN_C_ISNAN=isnand],,[ |
---|
1286 | #ifdef HAVE_CMATH |
---|
1287 | # include <cmath> |
---|
1288 | #else |
---|
1289 | # ifdef HAVE_MATH_H |
---|
1290 | # include <math.h> |
---|
1291 | # endif |
---|
1292 | #endif |
---|
1293 | #ifdef HAVE_CFLOAT |
---|
1294 | # include <cfloat> |
---|
1295 | #else |
---|
1296 | # ifdef HAVE_FLOAT_H |
---|
1297 | # include <float.h> |
---|
1298 | # endif |
---|
1299 | #endif |
---|
1300 | #ifdef HAVE_CIEEEFP |
---|
1301 | # include <cieeefp> |
---|
1302 | #else |
---|
1303 | # ifdef HAVE_IEEEFP_H |
---|
1304 | # include <ieeefp.h> |
---|
1305 | # endif |
---|
1306 | #endif]) |
---|
1307 | fi |
---|
1308 | if test -z "$COIN_C_ISNAN"; then |
---|
1309 | AC_MSG_WARN(Cannot find C-function for checking NaN.) |
---|
1310 | else |
---|
1311 | AC_DEFINE_UNQUOTED(COIN_C_ISNAN,[$COIN_C_ISNAN], |
---|
1312 | [Define to be the name of C-function for NaN check]) |
---|
1313 | fi |
---|
1314 | |
---|
1315 | AC_LANG_POP(C++) |
---|
1316 | ]) |
---|
1317 | |
---|
1318 | ########################################################################### |
---|
1319 | # COIN_LINK_FROM_FILELIST # |
---|
1320 | ########################################################################### |
---|
1321 | |
---|
1322 | # This macro creates links (or copies, if necessary) to files listed |
---|
1323 | # as content in a text file (second argument) into a target directory |
---|
1324 | # (first argument), which is created if it doesn't exist yet. If s link |
---|
1325 | # already exists, nothing happens. |
---|
1326 | |
---|
1327 | AC_DEFUN([AC_COIN_LINKCOPY_FROM_FILELIST], |
---|
1328 | [cmd="$3" |
---|
1329 | if test -e $srcdir/$2 ; then |
---|
1330 | my_target_dir="$1" |
---|
1331 | my_link_files=`cat $srcdir/$2` |
---|
1332 | my_dirname=`AS_DIRNAME($2)` |
---|
1333 | # if test -e $my_target_dir; then : ; else |
---|
1334 | # AS_MKDIR_P($my_target_dir) |
---|
1335 | # fi |
---|
1336 | for i in $my_link_files; do |
---|
1337 | #rm -rf $my_target_dir/$i |
---|
1338 | if test -e $my_target_dir/$i; then : ; else |
---|
1339 | dirn2=`AS_DIRNAME($my_target_dir/$i)` |
---|
1340 | if test -e $dirn2; then : ; else |
---|
1341 | AS_MKDIR_P($dirn2) |
---|
1342 | fi |
---|
1343 | $cmd $abs_source_dir/$my_dirname/$i $my_target_dir/$i |
---|
1344 | fi |
---|
1345 | done |
---|
1346 | else |
---|
1347 | AC_MSG_WARN([File list file $2 missing!]) |
---|
1348 | fi |
---|
1349 | ]) |
---|
1350 | |
---|
1351 | AC_DEFUN([AC_COIN_LINK_FROM_FILELIST], |
---|
1352 | [ |
---|
1353 | AC_REQUIRE([AC_COIN_LINK_INPUT_CMD]) |
---|
1354 | echo Creating links in $1 ... |
---|
1355 | AC_COIN_LINKCOPY_FROM_FILELIST($1, $2, $coin_link_input_cmd) |
---|
1356 | ]) |
---|
1357 | |
---|
1358 | ########################################################################### |
---|
1359 | # COIN_COPY_FROM_FILELIST # |
---|
1360 | ########################################################################### |
---|
1361 | |
---|
1362 | # Like COIN_LINK_FROM_FILELIST, but copies the files. |
---|
1363 | |
---|
1364 | AC_DEFUN([AC_COIN_COPY_FROM_FILELIST], |
---|
1365 | [ |
---|
1366 | echo Creating copies in $1 ... |
---|
1367 | AC_COIN_LINKCOPY_FROM_FILELIST($1, $2, [cp]) |
---|
1368 | ]) |
---|
1369 | |
---|
1370 | ########################################################################### |
---|
1371 | # COIN_EXAMPLE_FILES # |
---|
1372 | ########################################################################### |
---|
1373 | |
---|
1374 | # This macro determines the names of the example files (using the |
---|
1375 | # argument in an "ls" command) and sets up the variables EXAMPLE_FILES |
---|
1376 | # and EXAMPLE_CLEAN_FILES. If this is a VPATH configuration, it also |
---|
1377 | # creates soft links to the example files. |
---|
1378 | |
---|
1379 | AC_DEFUN([AC_COIN_EXAMPLE_FILES], |
---|
1380 | [AC_REQUIRE([AC_COIN_CHECK_VPATH]) |
---|
1381 | AC_REQUIRE([AC_COIN_ENABLE_DOSCOMPILE]) |
---|
1382 | AC_REQUIRE([AC_PROG_LN_S]) |
---|
1383 | |
---|
1384 | files=`cd $srcdir; ls $1` |
---|
1385 | # We need to do the following loop to make sure that are no newlines |
---|
1386 | # in the variable |
---|
1387 | for file in $files; do |
---|
1388 | EXAMPLE_FILES="$EXAMPLE_FILES $file" |
---|
1389 | done |
---|
1390 | if test $coin_vpath_config = yes; then |
---|
1391 | lnkcmd= |
---|
1392 | if test "$enable_doscompile" != no; then |
---|
1393 | lnkcmd=cp |
---|
1394 | fi |
---|
1395 | case "$CC" in |
---|
1396 | clang* ) ;; |
---|
1397 | cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*) |
---|
1398 | lnkcmd=cp ;; |
---|
1399 | esac |
---|
1400 | if test "x$lnkcmd" = xcp; then |
---|
1401 | AC_MSG_NOTICE([Copying example files ($1)]) |
---|
1402 | else |
---|
1403 | AC_MSG_NOTICE([Creating links to the example files ($1)]) |
---|
1404 | lnkcmd="$LN_S" |
---|
1405 | fi |
---|
1406 | for file in $EXAMPLE_FILES; do |
---|
1407 | rm -f $file |
---|
1408 | $lnkcmd $srcdir/$file $file |
---|
1409 | done |
---|
1410 | EXAMPLE_CLEAN_FILES="$EXAMPLE_CLEAN_FILES $1" |
---|
1411 | else |
---|
1412 | EXAMPLE_CLEAN_FILES="$EXAMPLE_CLEAN_FILES" |
---|
1413 | fi |
---|
1414 | |
---|
1415 | # In case there are compressed files, we create a variable with the |
---|
1416 | # uncompressed names |
---|
1417 | EXAMPLE_UNCOMPRESSED_FILES= |
---|
1418 | for file in $EXAMPLE_FILES; do |
---|
1419 | case $file in |
---|
1420 | *.gz) |
---|
1421 | EXAMPLE_UNCOMPRESSED_FILES="$EXAMPLE_UNCOMPRESSED_FILES `echo $file | sed -e s/.gz//`" |
---|
1422 | ;; |
---|
1423 | esac |
---|
1424 | done |
---|
1425 | |
---|
1426 | AC_SUBST(EXAMPLE_UNCOMPRESSED_FILES) |
---|
1427 | AC_SUBST(EXAMPLE_FILES) |
---|
1428 | AC_SUBST(EXAMPLE_CLEAN_FILES) |
---|
1429 | ]) #AC_COIN_EXAMPLE_FILES |
---|
1430 | |
---|
1431 | ########################################################################### |
---|
1432 | # COIN_CHECK_USER_LIBRARY # |
---|
1433 | ########################################################################### |
---|
1434 | # This macro sets up usage of a user library with header files. The assumption |
---|
1435 | # is that the header file(s) and library do not reside in standard system |
---|
1436 | # directories, hence both the include directory and link flags must be |
---|
1437 | # specified. There are two mandatory arguments and two optional arguments. |
---|
1438 | # |
---|
1439 | # The first argument (mandatory) should be a name (LibraryName) for the |
---|
1440 | # library. The second argument (mandatory) should be an abbreviation in |
---|
1441 | # upper case letters (LBRY) for the library. Ultimately, the macro will |
---|
1442 | # specify two variables, LBRYINCDIR and LBRYLIB, to be substituted in files |
---|
1443 | # generated during configuration; a preprocessor symbol COIN_HAS_LBRY; and a |
---|
1444 | # matching automake conditional COIN_HAS_LBRY. LBRYINCDIR should specify the |
---|
1445 | # directory containing include files for the library. LBRYLIB should specify |
---|
1446 | # the flags necessary to link to the library. A variable coin_has_lbry will |
---|
1447 | # be set to true or false, as appropriate. A variable lbry_libcheck will be |
---|
1448 | # be set to yes or no; no indicates link checks should not be attempted. |
---|
1449 | # |
---|
1450 | # The macro defines three configure arguments, --with-libraryname-incdir, |
---|
1451 | # --with-libraryname-lib, and --disable-libraryname-libcheck, by converting |
---|
1452 | # LibraryName to lower case. |
---|
1453 | # |
---|
1454 | # LBRYINCDIR and LBRYLIB can be specified as environment variables or as |
---|
1455 | # part of the configure command using --with-libraryname-incdir and |
---|
1456 | # --with-libraryname-lib, respectively. Command line arguments override |
---|
1457 | # environment variables. |
---|
1458 | # |
---|
1459 | # If a third argument is given, it should specify a file in LBRYINCDIR. The |
---|
1460 | # macro will check for the presence of the file. If a fourth argument is given, |
---|
1461 | # it should specify a function name, `fname'. The macro will attempt to link a |
---|
1462 | # trivial program containing a parameterless call to the function, `fname()', |
---|
1463 | # using the LBRYLIB flags. The link check uses C as the language; this has been |
---|
1464 | # adequate to date but has limitations. It is possible to disable the link |
---|
1465 | # check by specifying --disable-libraryname-libcheck. This is a workaround for |
---|
1466 | # instances where the link check does not work properly, for whatever reason. |
---|
1467 | # If you're trying to link to a Fortran library, consider using F77_FUNC or |
---|
1468 | # FC_FUNC to obtain a mangled fname appropriate for use from C code. For a C++ |
---|
1469 | # library, you're on your own unless the library declares some function with |
---|
1470 | # extern "C" linkage. Otherwise, you'll have to somehow find the mangled C++ |
---|
1471 | # name. |
---|
1472 | # A fifth argument can be specified to include linker flags that may be required |
---|
1473 | # to sucessfully perform the linking check. |
---|
1474 | # |
---|
1475 | # An optional sixth argument can be given to specify a list of targets. |
---|
1476 | # For each target X, the variables X_LIBS and X_PCLIBS will be extended by $LBRYLIB, |
---|
1477 | # if the library has been found and seems to work. |
---|
1478 | |
---|
1479 | AC_DEFUN([AC_COIN_CHECK_USER_LIBRARY], |
---|
1480 | [ AC_REQUIRE([AC_COIN_PROJECTDIR_INIT]) |
---|
1481 | AC_MSG_CHECKING(if user provides library for $1) |
---|
1482 | |
---|
1483 | # Check for header file directory |
---|
1484 | |
---|
1485 | AC_ARG_WITH(m4_tolower($1)-incdir, |
---|
1486 | AS_HELP_STRING([--with-m4_tolower($1)-incdir], |
---|
1487 | [specify the header file directory for library $1]), |
---|
1488 | [$2INCDIR=`cd $withval; pwd`]) |
---|
1489 | |
---|
1490 | # Check for library directory |
---|
1491 | |
---|
1492 | AC_ARG_WITH(m4_tolower($1)-lib, |
---|
1493 | AS_HELP_STRING([--with-m4_tolower($1)-lib], |
---|
1494 | [specify the flags used to link with the library $1]), |
---|
1495 | [$2LIB=$withval]) |
---|
1496 | |
---|
1497 | # Switch to disable library check if requested |
---|
1498 | |
---|
1499 | AC_ARG_ENABLE(m4_tolower($1)-libcheck, |
---|
1500 | AS_HELP_STRING([--disable-m4_tolower($1)-libcheck], |
---|
1501 | [skip the link check at configuration time]), |
---|
1502 | [m4_tolower($1)_libcheck=$enableval], |
---|
1503 | [m4_tolower($1)_libcheck=yes]) |
---|
1504 | |
---|
1505 | # At this point, if we're going to use the library, both LBRYINCDIR and |
---|
1506 | # LBRYLIB must be defined and not empty. |
---|
1507 | |
---|
1508 | if test x"$$2INCDIR" != x || test x"$$2LIB" != x; then |
---|
1509 | if test x"$$2INCDIR" = x || test x"$$2LIB" = x; then |
---|
1510 | AC_MSG_ERROR([You need to specify both an include directory and link flags to use library $1. Use --with-m4_tolower($1)-incdir of environment variable $$2INCDIR to specify the include directory. Use --with-m4_tolower($1)-lib or environment variable $$2LIB to specify link flags.]) |
---|
1511 | fi |
---|
1512 | m4_tolower(coin_has_$2)=true |
---|
1513 | AC_MSG_RESULT(yes) |
---|
1514 | else |
---|
1515 | m4_tolower(coin_has_$2)=false |
---|
1516 | AC_MSG_RESULT(no) |
---|
1517 | fi |
---|
1518 | |
---|
1519 | # If we have instructions for use, consider header and link checks. |
---|
1520 | |
---|
1521 | if test $m4_tolower(coin_has_$2) = true; then |
---|
1522 | |
---|
1523 | # If argument 3 (file) is given, check for the file. Typically this will be a |
---|
1524 | # header file, but that's not assumed. |
---|
1525 | |
---|
1526 | m4_ifval([$3], |
---|
1527 | [AC_COIN_CHECK_FILE([$$2INCDIR/$3],[], |
---|
1528 | [AC_MSG_ERROR([Cannot find file $3 in $$2INCDIR])])]) |
---|
1529 | |
---|
1530 | # Now see if we can link the function. There are arguments for and against |
---|
1531 | # assuming argument 3 is a header file declaring the function. A correct |
---|
1532 | # function declaration is the main argument in favour. Having to cope with |
---|
1533 | # possible dependencies or other oddities are the main arguments against. |
---|
1534 | # Force the use of C as the best single choice amongst C++, C, and Fortran. |
---|
1535 | # Obviously, this has limits. |
---|
1536 | |
---|
1537 | m4_ifvaln([$4], |
---|
1538 | [if test x"$m4_tolower($1)_libcheck" != xno; then |
---|
1539 | coin_save_LIBS="$LIBS" |
---|
1540 | LIBS="$$2LIB $5" |
---|
1541 | coin_$2_link=no |
---|
1542 | AC_LANG_PUSH(C) |
---|
1543 | for fnm in $4 ; do |
---|
1544 | AC_MSG_CHECKING([whether symbol $fnm is available with $2]) |
---|
1545 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[$fnm()]])], |
---|
1546 | [AC_MSG_RESULT(yes) |
---|
1547 | coin_$2_link=yes |
---|
1548 | break], |
---|
1549 | [AC_MSG_RESULT(no)]) |
---|
1550 | done |
---|
1551 | AC_LANG_POP(C) |
---|
1552 | LIBS="$coin_save_LIBS" |
---|
1553 | if test x"$coin_$2_link" != xyes ; then |
---|
1554 | AC_MSG_ERROR([Cannot find symbol(s) $4 with $2]) |
---|
1555 | fi |
---|
1556 | fi]) |
---|
1557 | |
---|
1558 | # If we make it this far, we've verified the file and linked the function. Add |
---|
1559 | # the necessary link flags to $6_{PC}LIBS and define the preprocessor symbol |
---|
1560 | # COIN_HAS_LBRY. |
---|
1561 | |
---|
1562 | coin_foreach_w([myvar], [$6], [ |
---|
1563 | m4_toupper(myvar)_LIBS="$$2LIB $m4_toupper(myvar)_LIBS" |
---|
1564 | m4_toupper(myvar)_PCLIBS="$$2LIB $m4_toupper(myvar)_PCLIBS" |
---|
1565 | m4_toupper(myvar)_LIBS_INSTALLED="$$2LIB $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
1566 | ]) |
---|
1567 | |
---|
1568 | AC_DEFINE(COIN_HAS_$2,[1],[Define to 1 if the $1 package is available]) |
---|
1569 | fi |
---|
1570 | |
---|
1571 | # Arrange for configure to substitute LBRYINCDIR and LBRYLIB and create the |
---|
1572 | # automake conditional. These actions must occur unconditionally. |
---|
1573 | |
---|
1574 | AC_SUBST($2INCDIR) |
---|
1575 | AC_SUBST($2LIB) |
---|
1576 | AM_CONDITIONAL(COIN_HAS_$2, test $m4_tolower(coin_has_$2) = true) |
---|
1577 | ]) #AC_COIN_CHECK_USER_LIBRARY |
---|
1578 | |
---|
1579 | ########################################################################### |
---|
1580 | # COIN_TRY_FLINK # |
---|
1581 | ########################################################################### |
---|
1582 | |
---|
1583 | # Auxilliary macro to test if a Fortran function name can be linked, |
---|
1584 | # given the current settings of LIBS. We determine from the context, what |
---|
1585 | # the currently active programming language is, and cast the name accordingly. |
---|
1586 | # The first argument is the name of the function/subroutine, in small letters, |
---|
1587 | # the second argument are the actions taken when the test works, and the |
---|
1588 | # third argument are the actions taken if the test fails. |
---|
1589 | |
---|
1590 | AC_DEFUN([AC_COIN_TRY_FLINK], |
---|
1591 | [case $ac_ext in |
---|
1592 | f) |
---|
1593 | AC_TRY_LINK(,[ call $1],[$2],[$3]) |
---|
1594 | ;; |
---|
1595 | c) |
---|
1596 | AC_F77_FUNC($1,cfunc$1) |
---|
1597 | if test x"$coin_need_flibs" = xyes; then |
---|
1598 | flink_try=no; |
---|
1599 | else |
---|
1600 | AC_TRY_LINK([void $cfunc$1();],[$cfunc$1()], |
---|
1601 | [flink_try=yes],[flink_try=no]) |
---|
1602 | fi |
---|
1603 | if test $flink_try = yes; then |
---|
1604 | $2 |
---|
1605 | else |
---|
1606 | if test x"$FLIBS" != x; then |
---|
1607 | flink_save_libs="$LIBS" |
---|
1608 | LIBS="$LIBS $FLIBS" |
---|
1609 | AC_TRY_LINK([void $cfunc$1();],[$cfunc$1()], |
---|
1610 | [LIBS="$flink_save_libs" |
---|
1611 | coin_need_flibs=yes |
---|
1612 | $2 |
---|
1613 | ], |
---|
1614 | [LIBS="$flink_save_libs" |
---|
1615 | $3]) |
---|
1616 | else |
---|
1617 | $3 |
---|
1618 | fi |
---|
1619 | fi |
---|
1620 | ;; |
---|
1621 | cc|cpp) |
---|
1622 | AC_F77_FUNC($1,cfunc$1) |
---|
1623 | if test x"$coin_need_flibs" = xyes; then |
---|
1624 | flink_try=no; |
---|
1625 | else |
---|
1626 | AC_TRY_LINK([extern "C" {void $cfunc$1();}],[$cfunc$1()], |
---|
1627 | [flink_try=yes],[flink_try=no]) |
---|
1628 | fi |
---|
1629 | if test $flink_try = yes; then |
---|
1630 | $2 |
---|
1631 | else |
---|
1632 | if test x"$FLIBS" != x; then |
---|
1633 | flink_save_libs="$LIBS" |
---|
1634 | LIBS="$LIBS $FLIBS" |
---|
1635 | AC_TRY_LINK([extern "C" {void $cfunc$1();}],[$cfunc$1()], |
---|
1636 | [LIBS="$flink_save_libs" |
---|
1637 | coin_need_flibs=yes |
---|
1638 | $2 |
---|
1639 | ], |
---|
1640 | [LIBS="$flink_save_libs" |
---|
1641 | $3]) |
---|
1642 | else |
---|
1643 | $3 |
---|
1644 | fi |
---|
1645 | fi |
---|
1646 | ;; |
---|
1647 | esac |
---|
1648 | ]) # AC_COIN_TRY_FLINK |
---|
1649 | |
---|
1650 | ########################################################################### |
---|
1651 | # COIN_DOXYGEN # |
---|
1652 | ########################################################################### |
---|
1653 | # |
---|
1654 | # This macro determines the configuration information for doxygen, the tool |
---|
1655 | # used to generate online documentation of COIN code. It takes one parameter, |
---|
1656 | # a list of projects (mixed-case, to match the directory names) that should |
---|
1657 | # be processed as external tag files. E.g., COIN_DOXYGEN([Clp Osi]). |
---|
1658 | # |
---|
1659 | # This macro will define the following variables: |
---|
1660 | # coin_have_doxygen Yes if doxygen is found, no otherwise |
---|
1661 | # coin_doxy_usedot Defaults to `yes'; --with-dot will still check to see |
---|
1662 | # if dot is available |
---|
1663 | # coin_doxy_tagname Name of doxygen tag file (placed in doxydoc directory) |
---|
1664 | # coin_doxy_logname Name of doxygen log file (placed in doxydoc directory) |
---|
1665 | # coin_doxy_tagfiles List of doxygen tag files used to reference other |
---|
1666 | # doxygen documentation |
---|
1667 | # coin_doxy_excludes Directories to exclude from doxygen processing |
---|
1668 | |
---|
1669 | AC_DEFUN([AC_COIN_DOXYGEN], |
---|
1670 | [ |
---|
1671 | |
---|
1672 | AC_MSG_NOTICE([configuring doxygen documentation options]) |
---|
1673 | |
---|
1674 | # Check to see if doxygen is available. |
---|
1675 | |
---|
1676 | AC_CHECK_PROG([coin_have_doxygen],[doxygen],[yes],[no]) |
---|
1677 | |
---|
1678 | # Look for the dot tool from the graphviz package, unless the user has |
---|
1679 | # disabled it. |
---|
1680 | |
---|
1681 | AC_ARG_WITH([dot], |
---|
1682 | AS_HELP_STRING([--with-dot], |
---|
1683 | [use dot (from graphviz) when creating documentation with |
---|
1684 | doxygen if available; --without-dot to disable]), |
---|
1685 | [],[withval=yes]) |
---|
1686 | if test x"$withval" = xno ; then |
---|
1687 | coin_doxy_usedot=NO |
---|
1688 | AC_MSG_CHECKING([for dot ]) |
---|
1689 | AC_MSG_RESULT([disabled]) |
---|
1690 | else |
---|
1691 | AC_CHECK_PROG([coin_doxy_usedot],[dot],[YES],[NO]) |
---|
1692 | fi |
---|
1693 | |
---|
1694 | # Generate a tag file name and a log file name |
---|
1695 | |
---|
1696 | AC_SUBST([coin_doxy_tagname],[doxydoc/${PACKAGE}_doxy.tag]) |
---|
1697 | AC_SUBST([coin_doxy_logname],[doxydoc/${PACKAGE}_doxy.log]) |
---|
1698 | |
---|
1699 | # Process the list of project names and massage them into possible doxygen |
---|
1700 | # doc'n directories. Prefer 1) classic external, source processed using |
---|
1701 | # a project-specific doxygen.conf, we use the tag file; 2) classic |
---|
1702 | # external, source processed using package doxygen.conf; 3) installed |
---|
1703 | # doxydoc. Alternatives 1) and 2) are only possible if the directory will be |
---|
1704 | # configured, which we can't know unless this is the package base configure, |
---|
1705 | # since coin_subdirs is only set there. Hence it's sufficient to check for |
---|
1706 | # membership. If we use a tag file from a classic external, exclude the |
---|
1707 | # source from doxygen processing when doxygen runs in the base directory. |
---|
1708 | |
---|
1709 | coin_doxy_tagfiles= |
---|
1710 | coin_doxy_excludes= |
---|
1711 | tmp="$1" |
---|
1712 | for proj in $tmp ; do |
---|
1713 | lc_proj=`echo $proj | [tr [A-Z] [a-z]]` |
---|
1714 | AC_MSG_CHECKING([for doxygen doc'n for $proj ]) |
---|
1715 | doxytag=${lc_proj}_doxy.tag |
---|
1716 | doxyfound=no |
---|
1717 | for chkProj in $coin_subdirs ; do |
---|
1718 | if test "$chkProj" = "$proj" ; then |
---|
1719 | # proj will be configured, hence doxydoc present in build tree |
---|
1720 | doxysrcdir="${srcdir}/${proj}" |
---|
1721 | # AC_MSG_NOTICE([Considering $doxysrcdir (base)]) |
---|
1722 | if test -d "$doxysrcdir" ; then |
---|
1723 | # with a doxydoc directory? |
---|
1724 | doxydir="$doxysrcdir/doxydoc" |
---|
1725 | # AC_MSG_NOTICE([Considering $doxydir (base)]) |
---|
1726 | # AC_MSG_NOTICE([Subdirs: $coin_subdirs)]) |
---|
1727 | if test -d "$doxydir" ; then |
---|
1728 | # use tag file; don't process source |
---|
1729 | eval doxydir="`pwd`/${proj}/doxydoc" |
---|
1730 | coin_doxy_tagfiles="$coin_doxy_tagfiles $doxydir/$doxytag=$doxydir/html" |
---|
1731 | AC_MSG_RESULT([$doxydir (tag)]) |
---|
1732 | coin_doxy_excludes="$coin_doxy_excludes */${proj}" |
---|
1733 | else |
---|
1734 | # will process the source -- nothing further to be done here |
---|
1735 | AC_MSG_RESULT([$doxysrcdir (src)]) |
---|
1736 | fi |
---|
1737 | doxyfound=yes |
---|
1738 | fi |
---|
1739 | fi |
---|
1740 | done |
---|
1741 | # Not built, fall back to installed tag file |
---|
1742 | if test $doxyfound = no ; then |
---|
1743 | eval doxydir="${datadir}/coin/doc/${proj}/doxydoc" |
---|
1744 | # AC_MSG_NOTICE([Considering $doxydir (install)]) |
---|
1745 | # AC_MSG_NOTICE([Subdirs: $coin_subdirs)]) |
---|
1746 | coin_doxy_tagfiles="$coin_doxy_tagfiles $doxydir/$doxytag=$doxydir/html" |
---|
1747 | AC_MSG_RESULT([$doxydir (tag)]) |
---|
1748 | fi |
---|
1749 | done |
---|
1750 | AC_SUBST([coin_doxy_tagfiles]) |
---|
1751 | AC_SUBST([coin_doxy_excludes]) |
---|
1752 | |
---|
1753 | ]) # AC_COIN_DOXYGEN |
---|
1754 | |
---|
1755 | |
---|
1756 | ########################################################################### |
---|
1757 | # COIN_HAS_PKGCONFIG # |
---|
1758 | ########################################################################### |
---|
1759 | |
---|
1760 | # This macro checks whether a pkg-config tool with a minimal version number |
---|
1761 | # is available. If so, then the variable PKGCONFIG is set to its path. |
---|
1762 | # If not, PKGCONFIG is set to "". The minimal version number can be given |
---|
1763 | # as first parameter, by default it is 0.16.0, since COIN-OR .pc files now |
---|
1764 | # include an URL field, which breaks pkg-config version <= 0.15. |
---|
1765 | # This macro is a modified version of PKG_PROG_PKG_CONFIG in pkg.m4. |
---|
1766 | # Further, the AM_CONDITIONAL COIN_HAS_PKGCONFIG is set and PKGCONFIG is |
---|
1767 | # AC_SUBST'ed. Finally, if this setup belongs to a project directory, then |
---|
1768 | # the search path for .pc files is assembled from the value of |
---|
1769 | # $PKG_CONFIG_PATH, the values of --prefix, --coin-instdir, and the directories |
---|
1770 | # named in a file ../coin_subdirs.txt or ../../coin_subdirs.txt in a variable |
---|
1771 | # COIN_PKG_CONFIG_PATH, which is also AC_SUBST'ed. For a path xxx given in the |
---|
1772 | # coin-subdirs.txt, also the directory xxx/pkgconfig is added, if existing. |
---|
1773 | |
---|
1774 | AC_DEFUN([AC_COIN_HAS_PKGCONFIG], |
---|
1775 | [AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility]) |
---|
1776 | |
---|
1777 | AC_ARG_ENABLE([pkg-config], |
---|
1778 | [AC_HELP_STRING([--disable-pkg-config],[disable use of pkg-config (if available)])], |
---|
1779 | [use_pkgconfig="$enableval"], |
---|
1780 | [use_pkgconfig=yes]) |
---|
1781 | |
---|
1782 | if test $use_pkgconfig = yes ; then |
---|
1783 | if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then |
---|
1784 | AC_PATH_TOOL([PKG_CONFIG], [pkg-config]) |
---|
1785 | fi |
---|
1786 | if test -n "$PKG_CONFIG"; then |
---|
1787 | _pkg_min_version=m4_default([$1], [0.16.0]) |
---|
1788 | AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version]) |
---|
1789 | if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then |
---|
1790 | AC_MSG_RESULT([yes]) |
---|
1791 | else |
---|
1792 | AC_MSG_RESULT([no]) |
---|
1793 | PKG_CONFIG="" |
---|
1794 | fi |
---|
1795 | fi |
---|
1796 | |
---|
1797 | # check if pkg-config supports the short-errors flag |
---|
1798 | if test -n "$PKG_CONFIG" && \ |
---|
1799 | $PKG_CONFIG --atleast-pkgconfig-version 0.20; then |
---|
1800 | pkg_short_errors=" --short-errors " |
---|
1801 | else |
---|
1802 | pkg_short_errors="" |
---|
1803 | fi |
---|
1804 | fi |
---|
1805 | |
---|
1806 | AM_CONDITIONAL([COIN_HAS_PKGCONFIG], [test -n "$PKG_CONFIG"]) |
---|
1807 | AC_SUBST(PKG_CONFIG) |
---|
1808 | |
---|
1809 | # assemble pkg-config search path for installed projects |
---|
1810 | COIN_PKG_CONFIG_PATH="$PKG_CONFIG_PATH" |
---|
1811 | |
---|
1812 | # let's assume that when installing into $prefix, then the user may have installed some other coin projects there before, so it's worth to have a look into there |
---|
1813 | # best would actually to use ${libdir}, since .pc files get installed into ${libdir}/pkgconfig, |
---|
1814 | # unfortunately, ${libdir} expands to ${exec_prefix}/lib and ${exec_prefix} to ${prefix}... |
---|
1815 | if test "x${prefix}" = xNONE ; then |
---|
1816 | COIN_PKG_CONFIG_PATH="${ac_default_prefix}/lib/pkgconfig:${ac_default_prefix}/share/pkgconfig:${COIN_PKG_CONFIG_PATH}" |
---|
1817 | else |
---|
1818 | COIN_PKG_CONFIG_PATH="${prefix}/lib/pkgconfig:${prefix}/share/pkgconfig:${COIN_PKG_CONFIG_PATH}" |
---|
1819 | fi |
---|
1820 | |
---|
1821 | AC_ARG_WITH([coin-instdir], |
---|
1822 | AC_HELP_STRING([--with-coin-instdir], |
---|
1823 | [prefix of installation directory for precompiled COIN packages]), |
---|
1824 | [if test -d "$withval"; then : ; else |
---|
1825 | AC_MSG_ERROR([argument for --with-coin-instdir not a directory]) |
---|
1826 | fi |
---|
1827 | COIN_PKG_CONFIG_PATH="$withval/lib/pkgconfig:$withval/share/pkgconfig:${COIN_PKG_CONFIG_PATH}" |
---|
1828 | ],[]) |
---|
1829 | |
---|
1830 | AC_SUBST(COIN_PKG_CONFIG_PATH) |
---|
1831 | |
---|
1832 | # assemble additional pkg-config search paths for uninstalled projects |
---|
1833 | if test x$coin_projectdir = xyes ; then |
---|
1834 | # if we are in a project setup, then in a classic setup, we want to find uninstalled projects |
---|
1835 | # their (relative) location is written to coin_subdirs.txt by the configure in the project base directory |
---|
1836 | # unfortunately, if the user set prefix, then we do not know where the project base directory is located |
---|
1837 | # but it is likely to be either .. (if we are a usual coin project) or ../.. (if we are a unusual coin project like ThirdParty or Data) |
---|
1838 | COIN_PKG_CONFIG_PATH_UNINSTALLED= |
---|
1839 | if test -e ../coin_subdirs.txt ; then |
---|
1840 | for i in `cat ../coin_subdirs.txt` ; do |
---|
1841 | if test -d ../$i ; then |
---|
1842 | COIN_PKG_CONFIG_PATH_UNINSTALLED="`cd ../$i; pwd`:${COIN_PKG_CONFIG_PATH_UNINSTALLED}" |
---|
1843 | fi |
---|
1844 | if test -d ../$i/pkgconfig ; then |
---|
1845 | COIN_PKG_CONFIG_PATH_UNINSTALLED="`cd ../$i/pkgconfig; pwd`:${COIN_PKG_CONFIG_PATH_UNINSTALLED}" |
---|
1846 | fi |
---|
1847 | done |
---|
1848 | fi |
---|
1849 | |
---|
1850 | if test -e ../../coin_subdirs.txt ; then |
---|
1851 | for i in `cat ../../coin_subdirs.txt` ; do |
---|
1852 | if test -d ../../$i ; then |
---|
1853 | COIN_PKG_CONFIG_PATH_UNINSTALLED="`cd ../../$i; pwd`:${COIN_PKG_CONFIG_PATH_UNINSTALLED}" |
---|
1854 | fi |
---|
1855 | if test -d ../../$i/pkgconfig ; then |
---|
1856 | COIN_PKG_CONFIG_PATH_UNINSTALLED="`cd ../../$i/pkgconfig; pwd`:${COIN_PKG_CONFIG_PATH_UNINSTALLED}" |
---|
1857 | fi |
---|
1858 | done |
---|
1859 | fi |
---|
1860 | |
---|
1861 | AC_SUBST(COIN_PKG_CONFIG_PATH_UNINSTALLED) |
---|
1862 | fi |
---|
1863 | |
---|
1864 | if test -n "$PKG_CONFIG" && test x$coin_cc_is_cl = xtrue; then |
---|
1865 | AC_MSG_WARN([Using pkg-config together with MS or Intel Compiler on Windows is not support by example Makefiles. Consider using --disable-pkg-config.]) |
---|
1866 | fi |
---|
1867 | |
---|
1868 | ]) |
---|
1869 | |
---|
1870 | ########################################################################### |
---|
1871 | # COIN_PKG_CHECK_PROJECT_EXISTS # |
---|
1872 | ########################################################################### |
---|
1873 | |
---|
1874 | # COIN_PKG_CHECK_PROJECT_EXISTS(PROJECT, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) |
---|
1875 | # |
---|
1876 | # Check to see whether a particular project exists. Similar |
---|
1877 | # to PKG_CHECK_MODULES(), but set only the variables $1_VERSION and $1_PKG_ERRORS variables |
---|
1878 | # |
---|
1879 | AC_DEFUN([AC_COIN_PKG_CHECK_PROJECT_EXISTS], |
---|
1880 | [AC_REQUIRE([AC_COIN_HAS_PKGCONFIG]) |
---|
1881 | if test -n "$PKG_CONFIG" ; then |
---|
1882 | if $PKG_CONFIG --exists "m4_tolower($1)"; then |
---|
1883 | m4_toupper($1)[]_VERSION=`$PKG_CONFIG --modversion "m4_tolower($1)" 2>/dev/null` |
---|
1884 | m4_ifval([$2], [$2], [:]) |
---|
1885 | else |
---|
1886 | m4_toupper($1)_PKG_ERRORS=`$PKG_CONFIG $pkg_short_errors --errors-to-stdout --print-errors "m4_tolower($1)"` |
---|
1887 | $3 |
---|
1888 | fi |
---|
1889 | else |
---|
1890 | AC_MSG_ERROR("Cannot check for existance of module $1 without pkg-config") |
---|
1891 | fi |
---|
1892 | ]) |
---|
1893 | |
---|
1894 | ########################################################################### |
---|
1895 | # COIN_PKG_CHECK_MODULE_EXISTS # |
---|
1896 | ########################################################################### |
---|
1897 | |
---|
1898 | # COIN_PKG_CHECK_MODULES_EXISTS(MODULE, PACKAGES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) |
---|
1899 | # |
---|
1900 | # Check to see whether a particular set of packages exists. |
---|
1901 | # Similar to PKG_CHECK_MODULES(), but set only the variable $1_VERSIONS and $1_PKG_ERRORS |
---|
1902 | # |
---|
1903 | AC_DEFUN([AC_COIN_PKG_CHECK_MODULE_EXISTS], |
---|
1904 | [AC_REQUIRE([AC_COIN_HAS_PKGCONFIG]) |
---|
1905 | if test -n "$PKG_CONFIG" ; then |
---|
1906 | if $PKG_CONFIG --exists "$2"; then |
---|
1907 | m4_toupper($1)[]_VERSIONS=`$PKG_CONFIG --modversion "$2" 2>/dev/null | tr '\n' ' '` |
---|
1908 | $3 |
---|
1909 | else |
---|
1910 | m4_toupper($1)_PKG_ERRORS=`$PKG_CONFIG $pkg_short_errors --errors-to-stdout --print-errors "$2"` |
---|
1911 | $4 |
---|
1912 | fi |
---|
1913 | else |
---|
1914 | AC_MSG_ERROR("Cannot check for existance of module $1 without pkg-config") |
---|
1915 | fi |
---|
1916 | ]) |
---|
1917 | |
---|
1918 | ########################################################################### |
---|
1919 | # COIN_PKG_HAS_MODULE # |
---|
1920 | ########################################################################### |
---|
1921 | |
---|
1922 | # COIN_PKG_HAS_MODULE(MODULE, PACKAGES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) |
---|
1923 | # |
---|
1924 | # Checks whether pkg-config files for a given set of packages is available. |
---|
1925 | # If so, sets MODULE_CFLAGS, MODULE_LIBS, and MODULES_DATA and executes ACTION-IF-FOUND. |
---|
1926 | # If not, then ACTION-IF-NOT-FOUND is executed. |
---|
1927 | # A reason for not finding a package is stored in MODULE_PKG_ERRORS |
---|
1928 | # |
---|
1929 | # -------------------------------------------------------------- |
---|
1930 | AC_DEFUN([AC_COIN_PKG_HAS_MODULE], |
---|
1931 | [AC_REQUIRE([AC_COIN_HAS_PKGCONFIG]) |
---|
1932 | |
---|
1933 | AC_COIN_PKG_CHECK_MODULE_EXISTS([$1],[$2], |
---|
1934 | [ cflags=`$PKG_CONFIG --cflags "$2" 2>/dev/null` |
---|
1935 | # pkg-config cannot handle spaces, so CYGPATH_W cannot be put into .pc files |
---|
1936 | # thus, we modify the cflags extracted from pkg-config by putting CYGPATH_W behind -I's |
---|
1937 | # but only do this if is not trivial |
---|
1938 | if test "$CYGPATH_W" != "echo" ; then |
---|
1939 | # need to put into brackets since otherwise autoconf replaces the brackets in the sed command |
---|
1940 | [cflags=`echo $cflags | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`] |
---|
1941 | fi |
---|
1942 | m4_toupper($1)[]_CFLAGS="$cflags" |
---|
1943 | m4_toupper($1)[]_LIBS=`$PKG_CONFIG --libs "$2" 2>/dev/null` |
---|
1944 | m4_toupper($1)[]_DATA=`$PKG_CONFIG --variable=datadir "$2" 2>/dev/null` |
---|
1945 | $3 |
---|
1946 | ], |
---|
1947 | [ $4 ]) |
---|
1948 | |
---|
1949 | ])# PKG_CHECK_MODULES |
---|
1950 | |
---|
1951 | ########################################################################### |
---|
1952 | # COIN_MAIN_PACKAGEDIR # |
---|
1953 | ########################################################################### |
---|
1954 | |
---|
1955 | # This macro substitutes COIN_MAIN_SUBDIR. |
---|
1956 | # If $2/$1 or $1 is in COIN_SKIP_PROJECTS, do nothing. |
---|
1957 | # If --with-$1-lib, --with-$1-incdir, or --with-$1-datadir is given, then assume that the package is installed. |
---|
1958 | # Otherwise, if the directory $2/$1 and the file $2/$1/$3 exist, check whether $2/$1/configure exists. |
---|
1959 | # If so, include this directory into the list of directories where configure and make recourse into. |
---|
1960 | # tolower(coin_has_$1) is set to "no" if the project source is not available or will not be compiled. |
---|
1961 | # Otherwise, it will be set to "yes". |
---|
1962 | |
---|
1963 | AC_DEFUN([AC_COIN_MAIN_PACKAGEDIR],[ |
---|
1964 | AC_MSG_CHECKING([whether source of project $1 is available and should be compiled]) |
---|
1965 | |
---|
1966 | m4_tolower(coin_has_$1)=notGiven |
---|
1967 | coin_reason= |
---|
1968 | |
---|
1969 | # check if user wants to skip project in any case |
---|
1970 | AC_ARG_VAR([COIN_SKIP_PROJECTS],[Set to the subdirectories of projects that should be skipped in the configuration]) |
---|
1971 | if test x"$COIN_SKIP_PROJECTS" != x; then |
---|
1972 | for dir in $COIN_SKIP_PROJECTS; do |
---|
1973 | if test $dir = "$1"; then |
---|
1974 | m4_tolower(coin_has_$1)="no" |
---|
1975 | coin_reason="$1 has been specified in COIN_SKIP_PROJECTS" |
---|
1976 | fi |
---|
1977 | m4_ifval($2,[ |
---|
1978 | if test $dir = "$2/$1"; then |
---|
1979 | m4_tolower(coin_has_$1)="no" |
---|
1980 | coin_reason="$2/$1 has been specified in COIN_SKIP_PROJECTS" |
---|
1981 | fi]) |
---|
1982 | done |
---|
1983 | fi |
---|
1984 | |
---|
1985 | if test "$m4_tolower(coin_has_$1)" != no; then |
---|
1986 | AC_ARG_WITH([m4_tolower($1)],, |
---|
1987 | [if test "$withval" = no ; then |
---|
1988 | m4_tolower(coin_has_$1)="no" |
---|
1989 | coin_reason="--without-m4_tolower($1) has been specified" |
---|
1990 | fi |
---|
1991 | ]) |
---|
1992 | fi |
---|
1993 | |
---|
1994 | if test "$m4_tolower(coin_has_$1)" != no; then |
---|
1995 | AC_ARG_WITH([m4_tolower($1)-lib], |
---|
1996 | AC_HELP_STRING([--with-m4_tolower($1)-lib], |
---|
1997 | [linker flags for using project $1]), |
---|
1998 | [if test "$withval" = no ; then |
---|
1999 | m4_tolower(coin_has_$1)="no" |
---|
2000 | coin_reason="--without-m4_tolower($1)-lib has been specified" |
---|
2001 | else |
---|
2002 | m4_tolower(coin_has_$1)="no" |
---|
2003 | coin_reason="--with-m4_tolower($1)-lib has been specified" |
---|
2004 | fi], |
---|
2005 | []) |
---|
2006 | fi |
---|
2007 | |
---|
2008 | if test "$m4_tolower(coin_has_$1)" != no; then |
---|
2009 | AC_ARG_WITH([m4_tolower($1)-incdir], |
---|
2010 | AC_HELP_STRING([--with-m4_tolower($1)-incdir], |
---|
2011 | [directory with header files for using project $1]), |
---|
2012 | [if test "$withval" = no ; then |
---|
2013 | m4_tolower(coin_has_$1)="no" |
---|
2014 | coin_reason="--without-m4_tolower($1)-incdir has been specified" |
---|
2015 | else |
---|
2016 | m4_tolower(coin_has_$1)="no" |
---|
2017 | coin_reason="--with-m4_tolower($1)-incdir has been specified" |
---|
2018 | fi], |
---|
2019 | []) |
---|
2020 | fi |
---|
2021 | |
---|
2022 | if test "$m4_tolower(coin_has_$1)" != no; then |
---|
2023 | AC_ARG_WITH([m4_tolower($1)-datadir], |
---|
2024 | AC_HELP_STRING([--with-m4_tolower($1)-datadir], |
---|
2025 | [directory with data files for using project $1]), |
---|
2026 | [if test "$withval" = no ; then |
---|
2027 | m4_tolower(coin_has_$1)="no" |
---|
2028 | coin_reason="--without-m4_tolower($1)-datadir has been specified" |
---|
2029 | else |
---|
2030 | m4_tolower(coin_has_$1)="no" |
---|
2031 | coin_reason="--with-m4_tolower($1)-datadir has been specified" |
---|
2032 | fi], |
---|
2033 | []) |
---|
2034 | fi |
---|
2035 | |
---|
2036 | m4_if(m4_tolower($1), blas, [ |
---|
2037 | if test $m4_tolower(coin_has_$1) != no; then |
---|
2038 | #--with-blas can overwrite --with-blas-lib, and can be set to BUILD to enforce building blas |
---|
2039 | AC_ARG_WITH([blas], |
---|
2040 | AC_HELP_STRING([--with-blas], [specify BLAS library (or BUILD to enforce use of ThirdParty/Blas)]), |
---|
2041 | [if test x"$withval" = "xno" ; then |
---|
2042 | coin_has_blas="no" |
---|
2043 | coin_reason="--without-blas has been specified" |
---|
2044 | elif test x"$withval" != "xBUILD" ; then |
---|
2045 | coin_has_blas="no" |
---|
2046 | coin_reason="--with-blas has been specified" |
---|
2047 | fi], |
---|
2048 | []) |
---|
2049 | fi |
---|
2050 | ]) |
---|
2051 | |
---|
2052 | m4_if(m4_tolower($1), lapack, [ |
---|
2053 | if test $m4_tolower(coin_has_$1) != skipping; then |
---|
2054 | #--with-lapack can overwrite --with-lapack-lib, and can be set to BUILD to enforce building lapack |
---|
2055 | AC_ARG_WITH([lapack], |
---|
2056 | AC_HELP_STRING([--with-lapack], [specify LAPACK library (or BUILD to enforce use of ThirdParty/Lapack)]), |
---|
2057 | [if test x"$withval" = "xno" ; then |
---|
2058 | coin_has_lapack="no" |
---|
2059 | coin_reason="--without-lapack has been specified" |
---|
2060 | elif test x"$withval" != "xBUILD" ; then |
---|
2061 | coin_has_lapack="no" |
---|
2062 | coin_reason="--with-lapack has been specified" |
---|
2063 | fi], |
---|
2064 | []) |
---|
2065 | fi |
---|
2066 | ]) |
---|
2067 | |
---|
2068 | # check if project is available in present directory |
---|
2069 | if test "$m4_tolower(coin_has_$1)" = notGiven; then |
---|
2070 | m4_tolower(coin_has_$1)=no |
---|
2071 | if test -d $srcdir/m4_ifval($2,[$2/],)$1; then |
---|
2072 | coin_reason="source in m4_ifval($2,[$2/],)$1" |
---|
2073 | # If a third argument is given, then we have to check if one one the files given in that third argument is present. |
---|
2074 | # If none of the files in the third argument is available, then we consider the project directory as non-existing. |
---|
2075 | # However, if no third argument is given, then this means that there should be no check, and existence of the directory is sufficient. |
---|
2076 | m4_ifvaln([$3], |
---|
2077 | [for i in $srcdir/m4_ifval($2,[$2/],)$1/$3; do |
---|
2078 | if test -r $i; then |
---|
2079 | m4_tolower(coin_has_$1)="yes" |
---|
2080 | else |
---|
2081 | m4_tolower(coin_has_$1)="no" |
---|
2082 | coin_reason="source file $i not available" |
---|
2083 | break |
---|
2084 | fi |
---|
2085 | done], |
---|
2086 | [ m4_tolower(coin_has_$1)="yes" ]) |
---|
2087 | fi |
---|
2088 | fi |
---|
2089 | |
---|
2090 | if test -z "$coin_reason" ; then |
---|
2091 | AC_MSG_RESULT([$m4_tolower(coin_has_$1)]) |
---|
2092 | else |
---|
2093 | AC_MSG_RESULT([$m4_tolower(coin_has_$1), $coin_reason]) |
---|
2094 | fi |
---|
2095 | |
---|
2096 | if test "$m4_tolower(coin_has_$1)" = yes ; then |
---|
2097 | if test -r $srcdir/m4_ifval($2,[$2/],)$1/configure; then |
---|
2098 | coin_subdirs="$coin_subdirs m4_ifval($2,[$2/],)$1" |
---|
2099 | AC_CONFIG_SUBDIRS(m4_ifval($2,[$2/],)$1) |
---|
2100 | fi |
---|
2101 | fi |
---|
2102 | ]) |
---|
2103 | |
---|
2104 | ########################################################################### |
---|
2105 | # COIN_CHECK_PACKAGE # |
---|
2106 | ########################################################################### |
---|
2107 | |
---|
2108 | # This macro checks for the existance of a COIN-OR package and provides compiler and linker flags to compile against this package. |
---|
2109 | # A package can consists of one or more COIN-OR or other projects. |
---|
2110 | # It defines the PACKAGE_CFLAGS, PACKAGE_LIBS, PACKAGE_DEPENDENCIES, and PACKAGE_DATA variables, referring to the compiler and linker |
---|
2111 | # flags to use when linking against this module, the libraries the package depends on, and the directories where the module data resists. |
---|
2112 | # The difference between PACKAGE_LIBS and PACKAGE_DEPENDENCIES is that PACKAGE_DEPENDENCIES does not contain arguments starting with '-', |
---|
2113 | # so it can be used to setup the _DEPENDENCIES variable in a Makefile.am. |
---|
2114 | # It also defines a COIN_HAS_PACKAGE preprocessor macro and makefile conditional. |
---|
2115 | # Further, tolower(coin_has_$1) is set to "yes". |
---|
2116 | # If a list of build targets using this projects is given in the third argument, |
---|
2117 | # then the compiler and linker variables and .pc file setup variable corresponding to this build target |
---|
2118 | # are extended with the values for this package. |
---|
2119 | # That is, for each build target X, the variables X_CFLAGS, X_LIBS, X_DEPENDENCIES, X_PCLIBS, X_PCREQUIRES are setup, |
---|
2120 | # whereas the last two specify the values to put into the "Libs:" and "Requires:" fields of the .pc file, resp. |
---|
2121 | # |
---|
2122 | # The first argument should be the name (PACKAGE) of the package (in correct lower |
---|
2123 | # and upper case). |
---|
2124 | # The second argument should be a (space separated) list of projects which this |
---|
2125 | # package consists of. Optionally, required version numbers can be added. |
---|
2126 | # The optional third argument should be a (space separated) list of build targets |
---|
2127 | # which use this package, if available. |
---|
2128 | # |
---|
2129 | # It is also possible to specify a preinstalled version of this package |
---|
2130 | # or to specify only the linker and compiler flags and data directory. |
---|
2131 | # |
---|
2132 | # If the user did not specify --with-$1-... flags and pkg-config is not available, |
---|
2133 | # COIN_CHECK_PACKAGE_FALLBACK($1, $2, $3) is called. |
---|
2134 | |
---|
2135 | AC_DEFUN([AC_COIN_CHECK_PACKAGE], |
---|
2136 | [AC_REQUIRE([AC_COIN_HAS_PKGCONFIG]) |
---|
2137 | AC_MSG_CHECKING([for COIN-OR package $1]) |
---|
2138 | |
---|
2139 | m4_tolower(coin_has_$1)=notGiven |
---|
2140 | |
---|
2141 | # check if user wants to skip package in any case |
---|
2142 | if test x"$COIN_SKIP_PROJECTS" != x; then |
---|
2143 | for dir in $COIN_SKIP_PROJECTS; do |
---|
2144 | if test $dir = "$1"; then |
---|
2145 | m4_tolower(coin_has_$1)=skipping |
---|
2146 | fi |
---|
2147 | done |
---|
2148 | fi |
---|
2149 | |
---|
2150 | if test "$m4_tolower(coin_has_$1)" != skipping; then |
---|
2151 | AC_ARG_WITH([m4_tolower($1)],, |
---|
2152 | [if test "$withval" = no ; then |
---|
2153 | m4_tolower(coin_has_$1)=skipping |
---|
2154 | fi |
---|
2155 | ]) |
---|
2156 | fi |
---|
2157 | |
---|
2158 | m4_toupper($1_LIBS)= |
---|
2159 | m4_toupper($1_CFLAGS)= |
---|
2160 | m4_toupper($1_DATA)= |
---|
2161 | m4_toupper($1_DEPENDENCIES)= |
---|
2162 | m4_toupper($1_PCLIBS)= |
---|
2163 | m4_toupper($1_PCREQUIRES)= |
---|
2164 | m4_toupper($1_DATA)= |
---|
2165 | AC_SUBST(m4_toupper($1_LIBS)) |
---|
2166 | AC_SUBST(m4_toupper($1_CFLAGS)) |
---|
2167 | AC_SUBST(m4_toupper($1_DATA)) |
---|
2168 | AC_SUBST(m4_toupper($1_DEPENDENCIES)) |
---|
2169 | AC_SUBST(m4_toupper($1_LIBS_INSTALLED)) |
---|
2170 | AC_SUBST(m4_toupper($1_CFLAGS_INSTALLED)) |
---|
2171 | AC_SUBST(m4_toupper($1_DATA_INSTALLED)) |
---|
2172 | coin_foreach_w([myvar], [$3], [ |
---|
2173 | AC_SUBST(m4_toupper(myvar)_CFLAGS) |
---|
2174 | AC_SUBST(m4_toupper(myvar)_LIBS) |
---|
2175 | AC_SUBST(m4_toupper(myvar)_PCLIBS) |
---|
2176 | AC_SUBST(m4_toupper(myvar)_PCREQUIRES) |
---|
2177 | AC_SUBST(m4_toupper(myvar)_DEPENDENCIES) |
---|
2178 | AC_SUBST(m4_toupper(myvar)_CFLAGS_INSTALLED) |
---|
2179 | AC_SUBST(m4_toupper(myvar)_LIBS_INSTALLED) |
---|
2180 | ]) |
---|
2181 | |
---|
2182 | #check if user provided LIBS, CFLAGS, or DATA for package or disables use of package |
---|
2183 | if test $m4_tolower(coin_has_$1) != skipping; then |
---|
2184 | AC_ARG_WITH([m4_tolower($1)-lib], |
---|
2185 | AC_HELP_STRING([--with-m4_tolower($1)-lib], |
---|
2186 | [linker flags for using package $1]), |
---|
2187 | [if test "$withval" = no ; then |
---|
2188 | m4_tolower(coin_has_$1)=skipping |
---|
2189 | else |
---|
2190 | m4_tolower(coin_has_$1)=yes |
---|
2191 | m4_toupper($1_LIBS)="$withval" |
---|
2192 | m4_toupper($1_PCLIBS)="$withval" |
---|
2193 | coin_foreach_w([myvar], [$3], [ |
---|
2194 | m4_toupper(myvar)_PCLIBS="$withval $m4_toupper(myvar)_PCLIBS" |
---|
2195 | m4_toupper(myvar)_LIBS="$withval $m4_toupper(myvar)_LIBS" |
---|
2196 | ]) |
---|
2197 | # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables |
---|
2198 | if test -z "$PKG_CONFIG" ; then |
---|
2199 | m4_toupper($1_LIBS_INSTALLED)="$withval" |
---|
2200 | coin_foreach_w([myvar], [$3], [m4_toupper(myvar)_LIBS_INSTALLED="$withval $m4_toupper(myvar)_LIBS_INSTALLED"]) |
---|
2201 | fi |
---|
2202 | fi |
---|
2203 | ], |
---|
2204 | []) |
---|
2205 | fi |
---|
2206 | |
---|
2207 | if test $m4_tolower(coin_has_$1) != skipping; then |
---|
2208 | AC_ARG_WITH([m4_tolower($1)-incdir], |
---|
2209 | AC_HELP_STRING([--with-m4_tolower($1)-incdir], |
---|
2210 | [directory with header files for using package $1]), |
---|
2211 | [if test "$withval" = no ; then |
---|
2212 | m4_tolower(coin_has_$1)=skipping |
---|
2213 | else |
---|
2214 | m4_tolower(coin_has_$1)=yes |
---|
2215 | m4_toupper($1_CFLAGS)="-I`${CYGPATH_W} $withval`" |
---|
2216 | coin_foreach_w([myvar], [$3], [m4_toupper(myvar)_CFLAGS="-I`${CYGPATH_W} $withval` $m4_toupper(myvar)_CFLAGS"]) |
---|
2217 | # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables |
---|
2218 | if test -z "$PKG_CONFIG" ; then |
---|
2219 | m4_toupper($1_CFLAGS_INSTALLED)="$m4_toupper($1_CFLAGS)" |
---|
2220 | coin_foreach_w([myvar], [$3], [m4_toupper(myvar)_CFLAGS_INSTALLED="$m4_toupper($1_CFLAGS) $m4_toupper(myvar)_CFLAGS_INSTALLED"]) |
---|
2221 | fi |
---|
2222 | fi |
---|
2223 | ], |
---|
2224 | []) |
---|
2225 | fi |
---|
2226 | |
---|
2227 | if test $m4_tolower(coin_has_$1) != skipping; then |
---|
2228 | AC_ARG_WITH([m4_tolower($1)-datadir], |
---|
2229 | AC_HELP_STRING([--with-m4_tolower($1)-datadir], |
---|
2230 | [directory with data files for using package $1]), |
---|
2231 | [if test "$withval" = no ; then |
---|
2232 | m4_tolower(coin_has_$1)=skipping |
---|
2233 | else |
---|
2234 | m4_tolower(coin_has_$1)=yes |
---|
2235 | m4_toupper($1_DATA)="$withval" |
---|
2236 | # if project flags are given by user and we build without pkg-config, then we need to setup the _INSTALLED variables |
---|
2237 | if test -z "$PKG_CONFIG" ; then |
---|
2238 | m4_toupper($1_DATA_INSTALLED)="$withval" |
---|
2239 | fi |
---|
2240 | fi |
---|
2241 | ], |
---|
2242 | []) |
---|
2243 | fi |
---|
2244 | |
---|
2245 | if test $m4_tolower(coin_has_$1) = notGiven; then |
---|
2246 | if test -n "$PKG_CONFIG" ; then |
---|
2247 | # set search path for pkg-config |
---|
2248 | # need to export variable to be sure that the following pkg-config gets these values |
---|
2249 | coin_save_PKG_CONFIG_PATH="$PKG_CONFIG_PATH" |
---|
2250 | PKG_CONFIG_PATH="$COIN_PKG_CONFIG_PATH:$COIN_PKG_CONFIG_PATH_UNINSTALLED" |
---|
2251 | export PKG_CONFIG_PATH |
---|
2252 | |
---|
2253 | # let pkg-config do it's magic |
---|
2254 | AC_COIN_PKG_HAS_MODULE([$1],[$2], |
---|
2255 | [ m4_tolower(coin_has_$1)=yes |
---|
2256 | AC_MSG_RESULT([yes: $m4_toupper($1)_VERSIONS]) |
---|
2257 | |
---|
2258 | # adjust linker flags for (i)cl compiler |
---|
2259 | # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl) |
---|
2260 | if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ; |
---|
2261 | then |
---|
2262 | m4_toupper($1_LIBS)=`echo " $m4_toupper($1_LIBS) " | [sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g']` |
---|
2263 | fi |
---|
2264 | m4_toupper($1_PCREQUIRES)="$2" |
---|
2265 | |
---|
2266 | # augment X_PCREQUIRES, X_CFLAGS, and X_LIBS for each build target X in $3 |
---|
2267 | coin_foreach_w([myvar], [$3], [ |
---|
2268 | m4_toupper(myvar)_PCREQUIRES="$2 $m4_toupper(myvar)_PCREQUIRES" |
---|
2269 | m4_toupper(myvar)_CFLAGS="$m4_toupper($1)_CFLAGS $m4_toupper(myvar)_CFLAGS" |
---|
2270 | m4_toupper(myvar)_LIBS="$m4_toupper($1)_LIBS $m4_toupper(myvar)_LIBS" |
---|
2271 | ]) |
---|
2272 | ], |
---|
2273 | [ m4_tolower(coin_has_$1)=notGiven |
---|
2274 | AC_MSG_RESULT([not given: $m4_toupper($1)_PKG_ERRORS]) |
---|
2275 | ]) |
---|
2276 | |
---|
2277 | # reset PKG_CONFIG_PATH variable |
---|
2278 | PKG_CONFIG_PATH="$coin_save_PKG_CONFIG_PATH" |
---|
2279 | export PKG_CONFIG_PATH |
---|
2280 | |
---|
2281 | else |
---|
2282 | AC_MSG_RESULT([skipped check via pkg-config, redirect to fallback]) |
---|
2283 | AC_COIN_CHECK_PACKAGE_FALLBACK([$1], [$2], [$3]) |
---|
2284 | fi |
---|
2285 | |
---|
2286 | else |
---|
2287 | AC_MSG_RESULT([$m4_tolower(coin_has_$1)]) |
---|
2288 | fi |
---|
2289 | |
---|
2290 | if test $m4_tolower(coin_has_$1) != skipping && |
---|
2291 | test $m4_tolower(coin_has_$1) != notGiven ; then |
---|
2292 | AC_DEFINE(m4_toupper(COIN_HAS_$1),[1],[Define to 1 if the $1 package is available]) |
---|
2293 | |
---|
2294 | AC_ARG_ENABLE([interpackage-dependencies], |
---|
2295 | AC_HELP_STRING([--disable-interpackage-dependencies], [disables deduction of Makefile dependencies from package linker flags]), |
---|
2296 | [], [enable_interpackage_dependencies=yes]) |
---|
2297 | |
---|
2298 | if test $enable_interpackage_dependencies = yes ; then |
---|
2299 | # construct dependencies variables from LIBS variables |
---|
2300 | # we add an extra space in LIBS so we can substitute out everything starting with " -" |
---|
2301 | # remove everything of the form -framework xxx as used on Mac and mkl* and libiomp5* as used on Windows |
---|
2302 | # then remove everything of the form -xxx |
---|
2303 | # also remove everything of the form `xxx`yyy (may have been added for cygwin/cl) |
---|
2304 | m4_toupper($1)_DEPENDENCIES=`echo " $m4_toupper($1)_LIBS" | [sed -e 's/ mkl[^ ]*//g' -e 's/ libiomp5[^ ]*//g' -e 's/ -framework *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g']` |
---|
2305 | coin_foreach_w([myvar], [$3], [ |
---|
2306 | m4_toupper(myvar)_DEPENDENCIES=`echo " $m4_toupper(myvar)_LIBS " | [sed -e 's/ mkl[^ ]*//g' -e 's/ libiomp5[^ ]*//g' -e 's/ -framework *[^ ]*//g' -e 's/ -[^ ]*//g' -e 's/\`[^\`]*\`[^ ]* //g']` |
---|
2307 | ]) |
---|
2308 | fi |
---|
2309 | |
---|
2310 | if test 1 = 0 ; then #change this test to enable a bit of debugging output |
---|
2311 | if test -n "$m4_toupper($1)_CFLAGS" ; then |
---|
2312 | AC_MSG_NOTICE([$1 CFLAGS are $m4_toupper($1)_CFLAGS]) |
---|
2313 | fi |
---|
2314 | if test -n "$m4_toupper($1)_LIBS" ; then |
---|
2315 | AC_MSG_NOTICE([$1 LIBS are $m4_toupper($1)_LIBS]) |
---|
2316 | fi |
---|
2317 | if test -n "$m4_toupper($1)_DEPENDENCIES" ; then |
---|
2318 | AC_MSG_NOTICE([$1 DEPENDENCIES are $m4_toupper($1)_DEPENDENCIES]) |
---|
2319 | fi |
---|
2320 | if test -n "$m4_toupper($1)_DATA" ; then |
---|
2321 | AC_MSG_NOTICE([$1 DATA is $m4_toupper($1)_DATA]) |
---|
2322 | fi |
---|
2323 | if test -n "$m4_toupper($1)_PCLIBS" ; then |
---|
2324 | AC_MSG_NOTICE([$1 PCLIBS are $m4_toupper($1)_PCLIBS]) |
---|
2325 | fi |
---|
2326 | if test -n "$m4_toupper($1)_PCREQUIRES" ; then |
---|
2327 | AC_MSG_NOTICE([$1 PCREQUIRES are $m4_toupper($1)_PCREQUIRES]) |
---|
2328 | fi |
---|
2329 | coin_foreach_w([myvar], [$3], [ |
---|
2330 | AC_MSG_NOTICE([myvar CFLAGS are $m4_toupper(myvar)_CFLAGS]) |
---|
2331 | AC_MSG_NOTICE([myvar LIBS are $m4_toupper(myvar)_LIBS]) |
---|
2332 | AC_MSG_NOTICE([myvar DEPENDENCIES are $m4_toupper(myvar)_DEPENDENCIES]) |
---|
2333 | ]) |
---|
2334 | fi |
---|
2335 | fi |
---|
2336 | |
---|
2337 | # Define the Makefile conditional |
---|
2338 | AM_CONDITIONAL(m4_toupper(COIN_HAS_$1), |
---|
2339 | [test $m4_tolower(coin_has_$1) != notGiven && |
---|
2340 | test $m4_tolower(coin_has_$1) != skipping]) |
---|
2341 | |
---|
2342 | ]) # AC_COIN_CHECK_PACKAGE |
---|
2343 | |
---|
2344 | ########################################################################### |
---|
2345 | # COIN_CHECK_PACKAGE_FALLBACK # |
---|
2346 | ########################################################################### |
---|
2347 | |
---|
2348 | # This macro is used by COIN_CHECK_PACKAGE, if it fails to find a package |
---|
2349 | # because pkg-config was disabled or is not available. |
---|
2350 | # |
---|
2351 | # For each project xxx specified in $2, it searches for a xxx-uninstalled.pc |
---|
2352 | # file in the directories specified in $COIN_PKG_CONFIG_PATH_UNINSTALLED. The |
---|
2353 | # latter variable is setup by COIN_HAS_PKGCONFIG and consists of the content |
---|
2354 | # of the coin_subdirs.txt file which has been created by configure in the |
---|
2355 | # base directory. The content of xxx-uninstalled.pc is parsed in order |
---|
2356 | # to defines the variables PACKAGE_CFLAGS, PACKAGE_LIBS, and PACKAGE_DATA, |
---|
2357 | # referring to the compiler and linker flags to use when linking against this |
---|
2358 | # package and the directory where the package data resists. Further, for each |
---|
2359 | # build target X specified in the third argument, the variables X_CFLAGS and |
---|
2360 | # X_LIBS are extended with the compiler and linker flags of this package and |
---|
2361 | # the variables X_PCLIBS and X_PCREQUIRES are extended by the list of linker |
---|
2362 | # flags and dependent projects as needed to setup a .pc file. The macros |
---|
2363 | # checks also dependencies of $2. Note that the PACKAGE_DATA variable is |
---|
2364 | # set to the content of datadir of the first .pc file that is parsed. |
---|
2365 | # Finally, for each X in the third argument, also variables |
---|
2366 | # X_CFLAGS_INSTALLED and X_LIBS_INSTALLED are setup. They contain the compiler |
---|
2367 | # and linker flags for X when all projects have been installed. Their content |
---|
2368 | # is assembled from the .pc files that correspond to installed projects. I.e., |
---|
2369 | # whenever a file proj-uninstalled.pc is parsed, then also a corresponding |
---|
2370 | # proj.pc file is parsed for compiler and linker flags, if available in the |
---|
2371 | # same directory. |
---|
2372 | # Similar, a variable PACKAGE_DATA_INSTALLED is setup to the content of datadir |
---|
2373 | # of the first .pc file that is parsed. |
---|
2374 | # |
---|
2375 | # If .pc files for all projects in $2 and their dependencies is found, |
---|
2376 | # tolower(coin_has_$1) is set to "yes". Otherwise, if some dependency |
---|
2377 | # is not found, tolower(coin_has_$1) is set to "notGiven". Further, a |
---|
2378 | # COIN_HAS_PACKAGE preprocessor macro and a makefile conditional are defined. |
---|
2379 | # |
---|
2380 | # The first argument should be the name (PACKAGE) of the package (in correct |
---|
2381 | # lower and upper case). The second argument should be the base names of the |
---|
2382 | # projects .pc file which define this package. The optional third argument |
---|
2383 | # should be a (space separated) list of build targets which use this package, |
---|
2384 | # if available. |
---|
2385 | # |
---|
2386 | # $1 is not checked for $COIN_SKIP_PROJECTS, since we only look into |
---|
2387 | # $COIN_PKG_CONFIG_PATH_UNINSTALLED. When the content of this variable was |
---|
2388 | # setup in the base directory, $COIN_SKIP_PROJECTS has already been considered. |
---|
2389 | |
---|
2390 | AC_DEFUN([AC_COIN_CHECK_PACKAGE_FALLBACK], |
---|
2391 | [AC_REQUIRE([AC_COIN_HAS_PKGCONFIG]) |
---|
2392 | AC_MSG_CHECKING([for COIN-OR package $1 (fallback)]) |
---|
2393 | |
---|
2394 | m4_tolower(coin_has_$1)=notGiven |
---|
2395 | m4_toupper($1_LIBS)= |
---|
2396 | m4_toupper($1_LIBS_INSTALLED)= |
---|
2397 | m4_toupper($1_CFLAGS)= |
---|
2398 | m4_toupper($1_CFLAGS_INSTALLED)= |
---|
2399 | m4_toupper($1_DATA)= |
---|
2400 | m4_toupper($1_DATA_INSTALLED)= |
---|
2401 | m4_toupper($1_PCLIBS)= |
---|
2402 | m4_toupper($1_PCREQUIRES)= |
---|
2403 | |
---|
2404 | # initial list of dependencies is "$2", but we need to filter out version number specifications (= x, <= x, >= x, != x) |
---|
2405 | projtoprocess="m4_bpatsubsts([$2], [<?>?!?=[ ]*[^ ]+])" |
---|
2406 | |
---|
2407 | # we first expand the list of projects to process by adding all dependencies just behind the project which depends on it |
---|
2408 | # further, we collect the list of corresponding .pc files, but do this in reverse order, because we need this order afterwards |
---|
2409 | # the latter we also do with .pc files corresponding to the installed projects, which will be needed to setup Makefiles for examples |
---|
2410 | # also, we setup the DATA variable |
---|
2411 | allproj="" |
---|
2412 | allpcfiles="" |
---|
2413 | allpcifiles="" |
---|
2414 | while test "x$projtoprocess" != x ; do |
---|
2415 | |
---|
2416 | for proj in $projtoprocess ; do |
---|
2417 | # if $proj is available and configured, then a project-uninstalled.pc file should have been created, so search for it |
---|
2418 | pcfile="" |
---|
2419 | save_IFS="$IFS" |
---|
2420 | IFS=":" |
---|
2421 | for dir in $COIN_PKG_CONFIG_PATH_UNINSTALLED ; do |
---|
2422 | # the base directory configure should have setup coin_subdirs.txt in a way that it does not contain projects that should be skipped, so we do not need to test this here again |
---|
2423 | if test -r "$dir/${proj}-uninstalled.pc" ; then |
---|
2424 | pcfile="$dir/$proj-uninstalled.pc" |
---|
2425 | if test -r "$dir/${proj}.pc" ; then |
---|
2426 | pcifile="$dir/${proj}.pc" |
---|
2427 | else |
---|
2428 | AC_MSG_WARN([Found $pcfile, but $dir/${proj}.pc is not available. This may break Makefile's of examples.]) |
---|
2429 | pcifile= |
---|
2430 | fi |
---|
2431 | break |
---|
2432 | fi |
---|
2433 | done |
---|
2434 | IFS="$save_IFS" |
---|
2435 | |
---|
2436 | if test "x$pcfile" != x ; then |
---|
2437 | # read dependencies from $pcfile and filter it |
---|
2438 | projrequires=[`sed -n -e 's/Requires://gp' "$pcfile" | sed -e 's/<\{0,1\}>\{0,1\}=[ ]\{0,\}[^ ]\{1,\}//g'`] |
---|
2439 | |
---|
2440 | # add projrequires to the front of the list of projects that have to be processed next |
---|
2441 | # at the same time, remove $proj from this list |
---|
2442 | projtoprocess=[`echo $projtoprocess | sed -e "s/$proj/$projrequires/"`] |
---|
2443 | |
---|
2444 | # read DATA from $pcfile, if _DATA is still empty |
---|
2445 | if test "x$m4_toupper($1_DATA)" = x ; then |
---|
2446 | projdatadir= |
---|
2447 | [pcfilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcfile`] |
---|
2448 | eval `sh -c "$pcfilemod"` |
---|
2449 | m4_toupper($1_DATA)="$projdatadir" |
---|
2450 | fi |
---|
2451 | |
---|
2452 | allproj="$allproj $proj" |
---|
2453 | allpcfiles="$pcfile:$allpcfiles" |
---|
2454 | |
---|
2455 | else |
---|
2456 | AC_MSG_RESULT([no, dependency $proj not available]) |
---|
2457 | allproj=fail |
---|
2458 | break 2 |
---|
2459 | fi |
---|
2460 | |
---|
2461 | if test "x$pcifile" != x ; then |
---|
2462 | allpcifiles="$pcifile:$allpcifiles" |
---|
2463 | |
---|
2464 | # read DATA_INSTALLED from $pcifile, if _DATA_INSTALLED is still empty |
---|
2465 | if test "x$m4_toupper($1_DATA_INSTALLED)" = x ; then |
---|
2466 | projdatadir= |
---|
2467 | [pcifilemod=`sed -e '/[a-zA-Z]:/d' -e 's/datadir=\(.*\)/echo projdatadir=\\\\"\1\\\\"/g' $pcifile`] |
---|
2468 | eval `sh -c "$pcifilemod"` |
---|
2469 | if test "${CYGPATH_W}" != "echo"; then |
---|
2470 | projdatadir="\`\$(CYGPATH_W) ${projdatadir} | sed -e 's/\\\\\\\\/\\\\\\\\\\\\\\\\/g'\`" |
---|
2471 | fi |
---|
2472 | m4_toupper($1_DATA_INSTALLED)="$projdatadir" |
---|
2473 | fi |
---|
2474 | |
---|
2475 | fi |
---|
2476 | |
---|
2477 | break |
---|
2478 | done |
---|
2479 | |
---|
2480 | # remove spaces on begin of $projtoprocess |
---|
2481 | projtoprocess=`echo $projtoprocess | sed -e 's/^[ ]*//'` |
---|
2482 | |
---|
2483 | done |
---|
2484 | |
---|
2485 | if test "$allproj" != fail ; then |
---|
2486 | |
---|
2487 | # now go through the list of .pc files and assemble compiler and linker flags |
---|
2488 | # important is here to obey the reverse order that has been setup before, |
---|
2489 | # since then libraries that are required by several others should be after these other libraries |
---|
2490 | pcfilesprocessed="" |
---|
2491 | |
---|
2492 | save_IFS="$IFS" |
---|
2493 | IFS=":" |
---|
2494 | for pcfile in $allpcfiles ; do |
---|
2495 | |
---|
2496 | # if $pcfile has been processed already, skip this round |
---|
2497 | if test "x$pcfilesprocessed" != x ; then |
---|
2498 | for pcfiledone in $pcfilesprocessed ; do |
---|
2499 | if test "$pcfiledone" = "$pcfile" ; then |
---|
2500 | continue 2 |
---|
2501 | fi |
---|
2502 | done |
---|
2503 | fi |
---|
2504 | |
---|
2505 | # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags: |
---|
2506 | # replace "Libs:" by "echo projlibs=" |
---|
2507 | # replace "Cflags:" by "echo projcflags=" |
---|
2508 | # remove every line starting with <some word>: |
---|
2509 | [pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`] |
---|
2510 | |
---|
2511 | # set projcflags and projlibs variables by running $pcfilemod |
---|
2512 | # under mingw, the current IFS seem to make the : in the paths of the gfortran libs go away, so we temporarily set IFS back to its default |
---|
2513 | projcflags= |
---|
2514 | projlibs= |
---|
2515 | IFS="$save_IFS" |
---|
2516 | eval `sh -c "$pcfilemod"` |
---|
2517 | IFS=":" |
---|
2518 | |
---|
2519 | # add CYGPATH_W cludge into include flags and set CFLAGS variable |
---|
2520 | if test "${CYGPATH_W}" != "echo"; then |
---|
2521 | projcflags=[`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`] |
---|
2522 | fi |
---|
2523 | m4_toupper($1_CFLAGS)="$projcflags $m4_toupper($1_CFLAGS)" |
---|
2524 | |
---|
2525 | # set LIBS variable |
---|
2526 | m4_toupper($1_LIBS)="$projlibs $m4_toupper($1_LIBS)" |
---|
2527 | |
---|
2528 | # remember that we have processed $pcfile |
---|
2529 | pcfilesprocessed="$pcfilesprocessed:$pcfile" |
---|
2530 | |
---|
2531 | done |
---|
2532 | IFS="$save_IFS" |
---|
2533 | |
---|
2534 | |
---|
2535 | # now go through the list of .pc files for installed projects and assemble compiler and linker flags |
---|
2536 | # important is here again to obey the reverse order that has been setup before, |
---|
2537 | # since then libraries that are required by several others should be after these other libraries |
---|
2538 | pcfilesprocessed="" |
---|
2539 | |
---|
2540 | save_IFS="$IFS" |
---|
2541 | IFS=":" |
---|
2542 | for pcfile in $allpcifiles ; do |
---|
2543 | |
---|
2544 | # if $pcfile has been processed already, skip this round |
---|
2545 | if test "x$pcfilesprocessed" != x ; then |
---|
2546 | for pcfiledone in $pcfilesprocessed ; do |
---|
2547 | if test "$pcfiledone" = "$pcfile" ; then |
---|
2548 | continue 2 |
---|
2549 | fi |
---|
2550 | done |
---|
2551 | fi |
---|
2552 | |
---|
2553 | # modify .pc file to a shell script that prints shell commands for setting the compiler and library flags: |
---|
2554 | # replace "Libs:" by "echo projlibs=" |
---|
2555 | # replace "Cflags:" by "echo projcflags=" |
---|
2556 | # remove every line starting with <some word>: |
---|
2557 | [pcfilemod=`sed -e 's/Libs:\(.*\)$/echo projlibs=\\\\"\1\\\\"/g' -e 's/Cflags:\(.*\)/echo projcflags=\\\\"\1\\\\"/g' -e '/^[a-zA-Z]*:/d' $pcfile`] |
---|
2558 | |
---|
2559 | # set projcflags and projlibs variables by running $pcfilemod |
---|
2560 | # under mingw, the current IFS seem to make the : in the paths of the gfortran libs go away, so we temporarily set IFS back to its default |
---|
2561 | projcflags= |
---|
2562 | projlibs= |
---|
2563 | IFS="$save_IFS" |
---|
2564 | eval `sh -c "$pcfilemod"` |
---|
2565 | IFS=":" |
---|
2566 | |
---|
2567 | # add CYGPATH_W cludge into include flags and set CFLAGS variable |
---|
2568 | if test "${CYGPATH_W}" != "echo"; then |
---|
2569 | projcflags=[`echo "$projcflags" | sed -e 's/-I\([^ ]*\)/-I\`${CYGPATH_W} \1\`/g'`] |
---|
2570 | fi |
---|
2571 | m4_toupper($1_CFLAGS_INSTALLED)="$projcflags $m4_toupper($1_CFLAGS_INSTALLED)" |
---|
2572 | |
---|
2573 | # set LIBS variable |
---|
2574 | m4_toupper($1_LIBS_INSTALLED)="$projlibs $m4_toupper($1_LIBS_INSTALLED)" |
---|
2575 | |
---|
2576 | # remember that we have processed $pcfile |
---|
2577 | pcfilesprocessed="$pcfilesprocessed:$pcfile" |
---|
2578 | |
---|
2579 | done |
---|
2580 | IFS="$save_IFS" |
---|
2581 | |
---|
2582 | |
---|
2583 | # finish up |
---|
2584 | m4_tolower(coin_has_$1)=yes |
---|
2585 | AC_MSG_RESULT([yes]) |
---|
2586 | AC_DEFINE(m4_toupper(COIN_HAS_$1),[1],[Define to 1 if the $1 package is available]) |
---|
2587 | |
---|
2588 | # adjust linker flags for (i)cl compiler |
---|
2589 | # for the LIBS, we replace everything of the form "/somepath/name.lib" by "`$(CYGPATH_W) /somepath/`name.lib | sed -e s|\|/|g" (where we have to use excessive many \ to get the \ into the command line for cl), |
---|
2590 | # for the LIBS_INSTALLED, we replace everything of the form "/somepath/" by "`$(CYGPATH_W) /somepath/`", |
---|
2591 | # everything of the form "-lname" by "libname.lib", and |
---|
2592 | # everything of the form "-Lpath" by "-libpath:`$(CYGPATH_W) path` |
---|
2593 | if test x$coin_cxx_is_cl = xtrue || test x$coin_cc_is_cl = xtrue ; |
---|
2594 | then |
---|
2595 | m4_toupper($1_LIBS)=`echo " $m4_toupper($1_LIBS) " | [sed -e 's/ \(\/[^ ]*\/\)\([^ ]*\)\.lib / \`$(CYGPATH_W) \1 | sed -e "s|\\\\\\\\\\\\\\\\\\\\|\/|g"\`\2.lib /g']` |
---|
2596 | m4_toupper($1_LIBS_INSTALLED)=`echo " $m4_toupper($1_LIBS_INSTALLED)" | [sed -e 's/ \(\/[^ ]*\/\)/ \`$(CYGPATH_W) \1\`/g' -e 's/ -l\([^ ]*\)/ lib\1.lib/g' -e 's/ -L\([^ ]*\)/ -libpath:\`$(CYGPATH_W) \1\`/g']` |
---|
2597 | fi |
---|
2598 | |
---|
2599 | m4_toupper($1_PCREQUIRES)="$2" |
---|
2600 | coin_foreach_w([myvar], [$3], [ |
---|
2601 | m4_toupper(myvar)_PCREQUIRES="$2 $m4_toupper(myvar)_PCREQUIRES" |
---|
2602 | m4_toupper(myvar)_CFLAGS="$m4_toupper($1)_CFLAGS $m4_toupper(myvar)_CFLAGS" |
---|
2603 | m4_toupper(myvar)_LIBS="$m4_toupper($1)_LIBS $m4_toupper(myvar)_LIBS" |
---|
2604 | m4_toupper(myvar)_CFLAGS_INSTALLED="$m4_toupper($1)_CFLAGS_INSTALLED $m4_toupper(myvar)_CFLAGS_INSTALLED" |
---|
2605 | m4_toupper(myvar)_LIBS_INSTALLED="$m4_toupper($1)_LIBS_INSTALLED $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
2606 | ]) |
---|
2607 | |
---|
2608 | fi |
---|
2609 | |
---|
2610 | AM_CONDITIONAL(m4_toupper(COIN_HAS_$1), |
---|
2611 | [test $m4_tolower(coin_has_$1) != notGiven && |
---|
2612 | test $m4_tolower(coin_has_$1) != skipping]) |
---|
2613 | |
---|
2614 | ]) # AC_COIN_CHECK_PACKAGE_FALLBACK |
---|
2615 | |
---|
2616 | ########################################################################### |
---|
2617 | # COIN_CHECK_PACKAGE_BLAS # |
---|
2618 | ########################################################################### |
---|
2619 | |
---|
2620 | # This macro checks for a library containing the BLAS library. It |
---|
2621 | # 1. checks the --with-blas argument |
---|
2622 | # 2. if --with-blas=BUILD has been specified goes to point 5 |
---|
2623 | # 3. if --with-blas has been specified to a working library, sets BLAS_LIBS |
---|
2624 | # to its value |
---|
2625 | # 4. tries standard libraries |
---|
2626 | # 5. calls COIN_CHECK_PACKAGE(Blas, [coinblas], [$1]) to check for |
---|
2627 | # ThirdParty/Blas |
---|
2628 | # The makefile conditional and preprocessor macro COIN_HAS_BLAS is defined. |
---|
2629 | # BLAS_LIBS is set to the flags required to link with a Blas library. |
---|
2630 | # For each build target X in $1, X_LIBS is extended with $BLAS_LIBS. |
---|
2631 | # In case 3 and 4, the flags to link to Blas are added to X_PCLIBS too. |
---|
2632 | # In case 5, Blas is added to X_PCREQUIRES. |
---|
2633 | |
---|
2634 | AC_DEFUN([AC_COIN_CHECK_PACKAGE_BLAS], |
---|
2635 | [ |
---|
2636 | AC_ARG_WITH([blas], |
---|
2637 | AC_HELP_STRING([--with-blas], |
---|
2638 | [specify BLAS library (or BUILD to enforce use of ThirdParty/Blas)]), |
---|
2639 | [use_blas="$withval"], [use_blas=]) |
---|
2640 | |
---|
2641 | # if user specified --with-blas-lib, then we should give COIN_CHECK_PACKAGE |
---|
2642 | # preference |
---|
2643 | AC_ARG_WITH([blas-lib],,[use_blas=BUILD]) |
---|
2644 | |
---|
2645 | # Check if user supplied option makes sense |
---|
2646 | if test x"$use_blas" != x; then |
---|
2647 | if test "$use_blas" = "BUILD"; then |
---|
2648 | # we come to this later |
---|
2649 | : |
---|
2650 | elif test "$use_blas" != "no"; then |
---|
2651 | AC_MSG_CHECKING([whether user supplied BLASLIB=\"$use_blas\" works]) |
---|
2652 | coin_need_flibs=no |
---|
2653 | coin_save_LIBS="$LIBS" |
---|
2654 | LIBS="$use_blas $LIBS" |
---|
2655 | AC_COIN_TRY_FLINK([daxpy], |
---|
2656 | [if test $coin_need_flibs = yes ; then |
---|
2657 | use_blas="$use_blas $FLIBS" |
---|
2658 | fi |
---|
2659 | AC_MSG_RESULT([yes: $use_blas])], |
---|
2660 | [AC_MSG_RESULT([no]) |
---|
2661 | AC_MSG_ERROR([user supplied BLAS library \"$use_blas\" does not work])]) |
---|
2662 | LIBS="$coin_save_LIBS" |
---|
2663 | fi |
---|
2664 | else |
---|
2665 | # Try to autodetect the library for blas based on build system |
---|
2666 | #AC_MSG_CHECKING([default locations for BLAS]) |
---|
2667 | skip_lblas_check=no |
---|
2668 | case $build in |
---|
2669 | *-sgi-*) |
---|
2670 | AC_MSG_CHECKING([whether -lcomplib.sgimath has BLAS]) |
---|
2671 | coin_need_flibs=no |
---|
2672 | coin_save_LIBS="$LIBS" |
---|
2673 | LIBS="-lcomplib.sgimath $LIBS" |
---|
2674 | AC_COIN_TRY_FLINK([daxpy], |
---|
2675 | [use_blas="-lcomplib.sgimath" |
---|
2676 | if test $coin_need_flibs = yes ; then |
---|
2677 | use_blas="$use_blas $FLIBS" |
---|
2678 | fi |
---|
2679 | AC_MSG_RESULT([yes: $use_blas]) |
---|
2680 | ], |
---|
2681 | [AC_MSG_RESULT([no])]) |
---|
2682 | LIBS="$coin_save_LIBS" |
---|
2683 | ;; |
---|
2684 | |
---|
2685 | # Ideally, we'd use -library=sunperf, but it's an imperfect world. Studio |
---|
2686 | # cc doesn't recognise -library, it wants -xlic_lib. Studio 12 CC doesn't |
---|
2687 | # recognise -xlic_lib. Libtool doesn't like -xlic_lib anyway. Sun claims |
---|
2688 | # that CC and cc will understand -library in Studio 13. The main extra |
---|
2689 | # function of -xlic_lib and -library is to arrange for the Fortran run-time |
---|
2690 | # libraries to be linked for C++ and C. We can arrange that explicitly. |
---|
2691 | *-*-solaris*) |
---|
2692 | AC_MSG_CHECKING([for BLAS in libsunperf]) |
---|
2693 | coin_need_flibs=no |
---|
2694 | coin_save_LIBS="$LIBS" |
---|
2695 | LIBS="-lsunperf $FLIBS $LIBS" |
---|
2696 | AC_COIN_TRY_FLINK([daxpy], |
---|
2697 | [use_blas='-lsunperf' |
---|
2698 | if test $coin_need_flibs = yes ; then |
---|
2699 | use_blas="$use_blas $FLIBS" |
---|
2700 | fi |
---|
2701 | AC_MSG_RESULT([yes: $use_blas]) |
---|
2702 | ], |
---|
2703 | [AC_MSG_RESULT([no])]) |
---|
2704 | LIBS="$coin_save_LIBS" |
---|
2705 | ;; |
---|
2706 | |
---|
2707 | *-cygwin* | *-mingw*) |
---|
2708 | # On cygwin, consider -lblas only if doscompile is disabled. The prebuilt |
---|
2709 | # library will want to link with cygwin, hence won't run standalone in DOS. |
---|
2710 | if test "$enable_doscompile" = mingw; then |
---|
2711 | skip_lblas_check=yes |
---|
2712 | fi |
---|
2713 | case "$CC" in |
---|
2714 | clang* ) ;; |
---|
2715 | cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*) |
---|
2716 | coin_save_LIBS="$LIBS" |
---|
2717 | AC_MSG_CHECKING([for BLAS in MKL (32bit)]) |
---|
2718 | LIBS="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib $LIBS" |
---|
2719 | AC_COIN_TRY_FLINK([daxpy], |
---|
2720 | [use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib' |
---|
2721 | AC_MSG_RESULT([yes: $use_blas]) |
---|
2722 | ], |
---|
2723 | [AC_MSG_RESULT([no])]) |
---|
2724 | LIBS="$coin_save_LIBS" |
---|
2725 | |
---|
2726 | if test "x$use_blas" = x ; then |
---|
2727 | AC_MSG_CHECKING([for BLAS in MKL (64bit)]) |
---|
2728 | LIBS="mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib $LIBS" |
---|
2729 | AC_COIN_TRY_FLINK([daxpy], |
---|
2730 | [use_blas='mkl_intel_lp64.lib mkl_sequential.lib mkl_core.lib' |
---|
2731 | AC_MSG_RESULT([yes: $use_blas]) |
---|
2732 | ], |
---|
2733 | [AC_MSG_RESULT([no])]) |
---|
2734 | LIBS="$coin_save_LIBS" |
---|
2735 | fi |
---|
2736 | ;; |
---|
2737 | esac |
---|
2738 | ;; |
---|
2739 | |
---|
2740 | *-darwin*) |
---|
2741 | AC_MSG_CHECKING([for BLAS in Veclib]) |
---|
2742 | coin_need_flibs=no |
---|
2743 | coin_save_LIBS="$LIBS" |
---|
2744 | LIBS="-framework vecLib $LIBS" |
---|
2745 | AC_COIN_TRY_FLINK([daxpy], |
---|
2746 | [use_blas='-framework vecLib' |
---|
2747 | if test $coin_need_flibs = yes ; then |
---|
2748 | use_blas="$use_blas $FLIBS" |
---|
2749 | fi |
---|
2750 | AC_MSG_RESULT([yes: $use_blas]) |
---|
2751 | ], |
---|
2752 | [AC_MSG_RESULT([no])]) |
---|
2753 | LIBS="$coin_save_LIBS" |
---|
2754 | ;; |
---|
2755 | esac |
---|
2756 | |
---|
2757 | if test -z "$use_blas" && test $skip_lblas_check = no; then |
---|
2758 | AC_MSG_CHECKING([whether -lblas has BLAS]) |
---|
2759 | coin_need_flibs=no |
---|
2760 | coin_save_LIBS="$LIBS" |
---|
2761 | LIBS="-lblas $LIBS" |
---|
2762 | AC_COIN_TRY_FLINK([daxpy], |
---|
2763 | [use_blas='-lblas' |
---|
2764 | if test $coin_need_flibs = yes ; then |
---|
2765 | use_blas="$use_blas $FLIBS" |
---|
2766 | fi |
---|
2767 | AC_MSG_RESULT([yes: $use_blas]) |
---|
2768 | ], |
---|
2769 | [AC_MSG_RESULT([no])]) |
---|
2770 | LIBS="$coin_save_LIBS" |
---|
2771 | fi |
---|
2772 | |
---|
2773 | # If we have no other ideas, consider building BLAS. |
---|
2774 | if test -z "$use_blas" ; then |
---|
2775 | use_blas=BUILD |
---|
2776 | fi |
---|
2777 | fi |
---|
2778 | |
---|
2779 | if test "x$use_blas" = xBUILD ; then |
---|
2780 | AC_COIN_CHECK_PACKAGE(Blas, [coinblas], [$1]) |
---|
2781 | |
---|
2782 | elif test "x$use_blas" != x && test "$use_blas" != no; then |
---|
2783 | coin_has_blas=yes |
---|
2784 | AM_CONDITIONAL([COIN_HAS_BLAS],[test 0 = 0]) |
---|
2785 | AC_DEFINE([COIN_HAS_BLAS],[1], [If defined, the BLAS Library is available.]) |
---|
2786 | BLAS_LIBS="$use_blas" |
---|
2787 | BLAS_CFLAGS= |
---|
2788 | BLAS_DATA= |
---|
2789 | AC_SUBST(BLAS_LIBS) |
---|
2790 | AC_SUBST(BLAS_CFLAGS) |
---|
2791 | AC_SUBST(BLAS_DATA) |
---|
2792 | coin_foreach_w([myvar], [$1], [ |
---|
2793 | m4_toupper(myvar)_PCLIBS="$BLAS_LIBS $m4_toupper(myvar)_PCLIBS" |
---|
2794 | m4_toupper(myvar)_LIBS="$BLAS_LIBS $m4_toupper(myvar)_LIBS" |
---|
2795 | m4_toupper(myvar)_LIBS_INSTALLED="$BLAS_LIBS $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
2796 | ]) |
---|
2797 | |
---|
2798 | else |
---|
2799 | coin_has_blas=no |
---|
2800 | AM_CONDITIONAL([COIN_HAS_BLAS],[test 0 = 1]) |
---|
2801 | fi |
---|
2802 | |
---|
2803 | coin_foreach_w([myvar], [$1], [ |
---|
2804 | AC_SUBST(m4_toupper(myvar)_PCLIBS) |
---|
2805 | AC_SUBST(m4_toupper(myvar)_LIBS) |
---|
2806 | AC_SUBST(m4_toupper(myvar)_LIBS_INSTALLED) |
---|
2807 | ]) |
---|
2808 | |
---|
2809 | ]) # AC_COIN_CHECK_PACKAGE_BLAS |
---|
2810 | |
---|
2811 | ########################################################################### |
---|
2812 | # COIN_CHECK_PACKAGE_LAPACK # |
---|
2813 | ########################################################################### |
---|
2814 | |
---|
2815 | # This macro checks for a library containing the LAPACK library. It |
---|
2816 | # 1. checks the --with-lapack argument |
---|
2817 | # 2. if --with-lapack=BUILD has been specified goes to point 5 |
---|
2818 | # 3. if --with-lapack has been specified to a working library, sets |
---|
2819 | # LAPACK_LIBS to its value |
---|
2820 | # 4. tries standard libraries |
---|
2821 | # 5. calls COIN_CHECK_PACKAGE(Lapack, [coinlapack], [$1]) to check for |
---|
2822 | # ThirdParty/Lapack |
---|
2823 | # The makefile conditional and preprocessor macro COIN_HAS_LAPACK is defined. |
---|
2824 | # LAPACK_LIBS is set to the flags required to link with a Lapack library. |
---|
2825 | # For each build target X in $1, X_LIBS is extended with $LAPACK_LIBS. |
---|
2826 | # In case 3 and 4, the flags to link to Lapack are added to X_PCLIBS too. |
---|
2827 | # In case 5, Lapack is added to X_PCREQUIRES. |
---|
2828 | # |
---|
2829 | # TODO: Lapack usually depends on Blas, so if we check for a system lapack library, |
---|
2830 | # shouldn't we include AC_COIN_CHECK_PACKAGE_BLAS first? |
---|
2831 | # However, if we look for coinlapack via AC_COIN_CHECK_PACKAGE(Lapack, [coinlapack], [$1]), |
---|
2832 | # then we will get Blas as dependency of coinlapack. |
---|
2833 | |
---|
2834 | AC_DEFUN([AC_COIN_CHECK_PACKAGE_LAPACK], |
---|
2835 | [ |
---|
2836 | AC_ARG_WITH([lapack], |
---|
2837 | AC_HELP_STRING([--with-lapack], |
---|
2838 | [specify LAPACK library (or BUILD to enforce use of ThirdParty/Lapack)]), |
---|
2839 | [use_lapack=$withval], [use_lapack=]) |
---|
2840 | |
---|
2841 | #if user specified --with-lapack-lib, then we should give COIN_HAS_PACKAGE preference |
---|
2842 | AC_ARG_WITH([lapack-lib],,[use_lapack=BUILD]) |
---|
2843 | |
---|
2844 | # Check if user supplied option makes sense |
---|
2845 | if test x"$use_lapack" != x; then |
---|
2846 | if test "$use_lapack" = "BUILD"; then |
---|
2847 | # we come to this later |
---|
2848 | : |
---|
2849 | elif test "$use_lapack" != no; then |
---|
2850 | AC_MSG_CHECKING([whether user supplied LAPACKLIB=\"$use_lapack\" works]) |
---|
2851 | coin_need_flibs=no |
---|
2852 | use_lapack="$use_lapack $BLAS_LIBS" |
---|
2853 | coin_save_LIBS="$LIBS" |
---|
2854 | LIBS="$use_lapack $LIBS" |
---|
2855 | AC_COIN_TRY_FLINK([dsyev], |
---|
2856 | [if test $coin_need_flibs = yes ; then |
---|
2857 | use_lapack="$use_lapack $FLIBS" |
---|
2858 | fi |
---|
2859 | AC_MSG_RESULT([yes: $use_lapack]) |
---|
2860 | ], |
---|
2861 | [AC_MSG_RESULT([no]) |
---|
2862 | AC_MSG_ERROR([user supplied LAPACK library \"$use_lapack\" does not work])]) |
---|
2863 | LIBS="$coin_save_LIBS" |
---|
2864 | fi |
---|
2865 | else |
---|
2866 | if test x$coin_has_blas = xyes; then |
---|
2867 | # First try to see if LAPACK is already available with BLAS library |
---|
2868 | AC_MSG_CHECKING([whether LAPACK is already available with BLAS library]) |
---|
2869 | coin_save_LIBS="$LIBS" |
---|
2870 | coin_need_flibs=no |
---|
2871 | LIBS="$BLAS_LIBS $LIBS" |
---|
2872 | AC_COIN_TRY_FLINK([dsyev], |
---|
2873 | [use_lapack="$BLAS_LIBS" |
---|
2874 | if test $coin_need_flibs = yes ; then |
---|
2875 | use_lapack="$use_lapack $FLIBS" |
---|
2876 | fi |
---|
2877 | AC_MSG_RESULT([yes: $use_lapack]) |
---|
2878 | ], |
---|
2879 | [AC_MSG_RESULT([no])]) |
---|
2880 | LIBS="$coin_save_LIBS" |
---|
2881 | fi |
---|
2882 | skip_llapack_check=no |
---|
2883 | if test -z "$use_lapack"; then |
---|
2884 | # Try to autodetect the library for lapack based on build system |
---|
2885 | case $build in |
---|
2886 | # TODO: Is this check actually needed here, since -lcomplib.sigmath should have been recognized as Blas library, |
---|
2887 | # and above it is checked whether the Blas library already contains Lapack |
---|
2888 | *-sgi-*) |
---|
2889 | AC_MSG_CHECKING([whether -lcomplib.sgimath has LAPACK]) |
---|
2890 | coin_save_LIBS="$LIBS" |
---|
2891 | coin_need_flibs=no |
---|
2892 | LIBS="-lcomplib.sgimath $BLAS_LIBS $LIBS" |
---|
2893 | AC_COIN_TRY_FLINK([dsyev], |
---|
2894 | [use_lapack="-lcomplib.sgimath $BLAS_LIBS" |
---|
2895 | if test $coin_need_flibs = yes ; then |
---|
2896 | use_lapack="$use_lapack $FLIBS" |
---|
2897 | fi |
---|
2898 | AC_MSG_RESULT([yes: $use_lapack]) |
---|
2899 | ], |
---|
2900 | [AC_MSG_RESULT([no])]) |
---|
2901 | LIBS="$coin_save_LIBS" |
---|
2902 | ;; |
---|
2903 | |
---|
2904 | # See comments in COIN_CHECK_PACKAGE_BLAS. |
---|
2905 | # TODO: Is this check actually needed here, since -lsunperf should have been recognized as Blas library, |
---|
2906 | # and above it is checked whether the Blas library already contains Lapack |
---|
2907 | *-*-solaris*) |
---|
2908 | AC_MSG_CHECKING([for LAPACK in libsunperf]) |
---|
2909 | coin_need_flibs=no |
---|
2910 | coin_save_LIBS="$LIBS" |
---|
2911 | LIBS="-lsunperf $BLAS_LIBS $FLIBS $LIBS" |
---|
2912 | AC_COIN_TRY_FLINK([dsyev], |
---|
2913 | [use_lapack='-lsunperf $BLAS_LIBS' |
---|
2914 | if test $coin_need_flibs = yes ; then |
---|
2915 | use_lapack="$use_lapack $FLIBS" |
---|
2916 | fi |
---|
2917 | AC_MSG_RESULT([yes: $use_lapack]) |
---|
2918 | ], |
---|
2919 | [AC_MSG_RESULT([no])]) |
---|
2920 | LIBS="$coin_save_LIBS" |
---|
2921 | ;; |
---|
2922 | # On cygwin, do this check only if doscompile is disabled. The prebuilt library |
---|
2923 | # will want to link with cygwin, hence won't run standalone in DOS. |
---|
2924 | |
---|
2925 | *-cygwin*) |
---|
2926 | if test "$enable_doscompile" = mingw; then |
---|
2927 | skip_llapack_check=yes |
---|
2928 | fi |
---|
2929 | ;; |
---|
2930 | |
---|
2931 | esac |
---|
2932 | fi |
---|
2933 | |
---|
2934 | if test -z "$use_lapack" && test $skip_llapack_check = no; then |
---|
2935 | AC_MSG_CHECKING([whether -llapack has LAPACK]) |
---|
2936 | coin_need_flibs=no |
---|
2937 | coin_save_LIBS="$LIBS" |
---|
2938 | LIBS="-llapack $BLAS_LIBS $LIBS" |
---|
2939 | AC_COIN_TRY_FLINK([dsyev], |
---|
2940 | [use_lapack='-llapack' |
---|
2941 | if test $coin_need_flibs = yes ; then |
---|
2942 | use_lapack="$use_lapack $FLIBS" |
---|
2943 | fi |
---|
2944 | AC_MSG_RESULT([yes: $use_lapack]) |
---|
2945 | ], |
---|
2946 | [AC_MSG_RESULT([no])]) |
---|
2947 | LIBS="$coin_save_LIBS" |
---|
2948 | fi |
---|
2949 | |
---|
2950 | # If we have no other ideas, consider building LAPACK. |
---|
2951 | if test -z "$use_lapack" ; then |
---|
2952 | use_lapack=BUILD |
---|
2953 | fi |
---|
2954 | fi |
---|
2955 | |
---|
2956 | if test "x$use_lapack" = xBUILD ; then |
---|
2957 | AC_COIN_CHECK_PACKAGE(Lapack, [coinlapack], [$1]) |
---|
2958 | |
---|
2959 | elif test "x$use_lapack" != x && test "$use_lapack" != no; then |
---|
2960 | coin_has_lapack=yes |
---|
2961 | AM_CONDITIONAL([COIN_HAS_LAPACK],[test 0 = 0]) |
---|
2962 | AC_DEFINE([COIN_HAS_LAPACK],[1], [If defined, the LAPACK Library is available.]) |
---|
2963 | LAPACK_LIBS="$use_lapack" |
---|
2964 | LAPACK_CFLAGS= |
---|
2965 | LAPACK_DATA= |
---|
2966 | AC_SUBST(LAPACK_LIBS) |
---|
2967 | AC_SUBST(LAPACK_CFLAGS) |
---|
2968 | AC_SUBST(LAPACK_DATA) |
---|
2969 | coin_foreach_w([myvar], [$1], [ |
---|
2970 | m4_toupper(myvar)_PCLIBS="$LAPACK_LIBS $m4_toupper(myvar)_PCLIBS" |
---|
2971 | m4_toupper(myvar)_LIBS="$LAPACK_LIBS $m4_toupper(myvar)_LIBS" |
---|
2972 | m4_toupper(myvar)_LIBS_INSTALLED="$LAPACK_LIBS $m4_toupper(myvar)_LIBS_INSTALLED" |
---|
2973 | ]) |
---|
2974 | |
---|
2975 | else |
---|
2976 | coin_has_lapack=no |
---|
2977 | AM_CONDITIONAL([COIN_HAS_LAPACK],[test 0 = 1]) |
---|
2978 | fi |
---|
2979 | |
---|
2980 | coin_foreach_w([myvar], [$1], [ |
---|
2981 | AC_SUBST(m4_toupper(myvar)_PCLIBS) |
---|
2982 | AC_SUBST(m4_toupper(myvar)_LIBS) |
---|
2983 | AC_SUBST(m4_toupper(myvar)_LIBS_INSTALLED) |
---|
2984 | ]) |
---|
2985 | |
---|
2986 | ]) # AC_COIN_CHECK_PACKAGE_LAPACK |
---|