source: stable/0.5/coin.m4 @ 1331

Last change on this file since 1331 was 1331, checked in by andreasw, 11 years ago

synchronizing BuildTools? stable/0.5 with trunk rev 1330

  • Property svn:keywords set to Author Date Id Revision
File size: 113.2 KB
Line 
1# Copyright (C) 2006, 2009 International Business Machines.
2# All Rights Reserved.
3# This file is distributed under the Common Public License.
4#
5## $Id: coin.m4 1331 2009-07-16 16:00:50Z andreasw $
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
13AC_PREREQ(2.59)
14
15###########################################################################
16#                           COIN_MAIN_SUBDIRS                             #
17###########################################################################
18
19# This macro sets up the recursion into configure scripts into
20# subdirectories.  Each possible subdirectory should be provided as a
21# new argument to this macro.  The current limit is 10 subdirectories.
22# This automatically also checks for the Data subdirectory.
23
24AC_DEFUN([AC_COIN_MAIN_SUBDIRS],
25[AC_ARG_VAR([COIN_SKIP_PROJECTS],[Set to the subdirectories of projects that should be skipped in the configuration])
26
27m4_ifvaln([$1],[AC_MSG_CHECKING(whether directory $1 is available)
28                coin_skip=no
29                if test x"$COIN_SKIP_PROJECTS" != x; then
30                  for dir in $COIN_SKIP_PROJECTS; do
31                    if test $dir = $1; then
32                      coin_skip=yes
33                    fi
34                  done
35                fi
36                if test $coin_skip = yes; then
37                  AC_MSG_RESULT(skipping)
38                elif test -r $srcdir/$1/configure; then
39                  coin_subdirs="$coin_subdirs $1"
40                  AC_MSG_RESULT(yes)
41                  AC_CONFIG_SUBDIRS($1)
42                else
43                  AC_MSG_RESULT(no)
44                fi])
45m4_ifvaln([$2],[AC_MSG_CHECKING(whether directory $2 is available)
46                coin_skip=no
47                if test x"$COIN_SKIP_PROJECTS" != x; then
48                  for dir in $COIN_SKIP_PROJECTS; do
49                    if test $dir = $2; then
50                      coin_skip=yes
51                    fi
52                  done
53                fi
54                if test $coin_skip = yes; then
55                  AC_MSG_RESULT(skipping)
56                elif test -r $srcdir/$2/configure; then
57                  coin_subdirs="$coin_subdirs $2"
58                  AC_MSG_RESULT(yes)
59                  AC_CONFIG_SUBDIRS($2)
60                else
61                  AC_MSG_RESULT(no)
62                fi])
63m4_ifvaln([$3],[AC_MSG_CHECKING(whether directory $3 is available)
64                coin_skip=no
65                if test x"$COIN_SKIP_PROJECTS" != x; then
66                  for dir in $COIN_SKIP_PROJECTS; do
67                    if test $dir = $3; then
68                      coin_skip=yes
69                    fi
70                  done
71                fi
72                if test $coin_skip = yes; then
73                  AC_MSG_RESULT(skipping)
74                elif test -r $srcdir/$3/configure; then
75                  coin_subdirs="$coin_subdirs $3"
76                  AC_MSG_RESULT(yes)
77                  AC_CONFIG_SUBDIRS($3)
78                else
79                  AC_MSG_RESULT(no)
80                fi])
81m4_ifvaln([$4],[AC_MSG_CHECKING(whether directory $4 is available)
82                coin_skip=no
83                if test x"$COIN_SKIP_PROJECTS" != x; then
84                  for dir in $COIN_SKIP_PROJECTS; do
85                    if test $dir = $4; then
86                      coin_skip=yes
87                    fi
88                  done
89                fi
90                if test $coin_skip = yes; then
91                  AC_MSG_RESULT(skipping)
92                elif test -r $srcdir/$4/configure; then
93                  coin_subdirs="$coin_subdirs $4"
94                  AC_MSG_RESULT(yes)
95                  AC_CONFIG_SUBDIRS($4)
96                else
97                  AC_MSG_RESULT(no)
98                fi])
99m4_ifvaln([$5],[AC_MSG_CHECKING(whether directory $5 is available)
100                coin_skip=no
101                if test x"$COIN_SKIP_PROJECTS" != x; then
102                  for dir in $COIN_SKIP_PROJECTS; do
103                    if test $dir = $5; then
104                      coin_skip=yes
105                    fi
106                  done
107                fi
108                if test $coin_skip = yes; then
109                  AC_MSG_RESULT(skipping)
110                elif test -r $srcdir/$5/configure; then
111                  coin_subdirs="$coin_subdirs $5"
112                  AC_MSG_RESULT(yes)
113                  AC_CONFIG_SUBDIRS($5)
114                else
115                  AC_MSG_RESULT(no)
116                fi])
117m4_ifvaln([$6],[AC_MSG_CHECKING(whether directory $6 is available)
118                coin_skip=no
119                if test x"$COIN_SKIP_PROJECTS" != x; then
120                  for dir in $COIN_SKIP_PROJECTS; do
121                    if test $dir = $6; then
122                      coin_skip=yes
123                    fi
124                  done
125                fi
126                if test $coin_skip = yes; then
127                  AC_MSG_RESULT(skipping)
128                elif test -r $srcdir/$6/configure; then
129                  coin_subdirs="$coin_subdirs $6"
130                  AC_MSG_RESULT(yes)
131                  AC_CONFIG_SUBDIRS($6)
132                else
133                  AC_MSG_RESULT(no)
134                fi])
135m4_ifvaln([$7],[AC_MSG_CHECKING(whether directory $7 is available)
136                coin_skip=no
137                if test x"$COIN_SKIP_PROJECTS" != x; then
138                  for dir in $COIN_SKIP_PROJECTS; do
139                    if test $dir = $7; then
140                      coin_skip=yes
141                    fi
142                  done
143                fi
144                if test $coin_skip = yes; then
145                  AC_MSG_RESULT(skipping)
146                elif test -r $srcdir/$7/configure; then
147                  coin_subdirs="$coin_subdirs $7"
148                  AC_MSG_RESULT(yes)
149                  AC_CONFIG_SUBDIRS($7)
150                else
151                  AC_MSG_RESULT(no)
152                fi])
153m4_ifvaln([$8],[AC_MSG_CHECKING(whether directory $8 is available)
154                coin_skip=no
155                if test x"$COIN_SKIP_PROJECTS" != x; then
156                  for dir in $COIN_SKIP_PROJECTS; do
157                    if test $dir = $8; then
158                      coin_skip=yes
159                    fi
160                  done
161                fi
162                if test $coin_skip = yes; then
163                  AC_MSG_RESULT(skipping)
164                elif test -r $srcdir/$8/configure; then
165                  coin_subdirs="$coin_subdirs $8"
166                  AC_MSG_RESULT(yes)
167                  AC_CONFIG_SUBDIRS($8)
168                else
169                  AC_MSG_RESULT(no)
170                fi])
171m4_ifvaln([$9],[AC_MSG_CHECKING(whether directory $9 is available)
172                coin_skip=no
173                if test x"$COIN_SKIP_PROJECTS" != x; then
174                  for dir in $COIN_SKIP_PROJECTS; do
175                    if test $dir = $9; then
176                      coin_skip=yes
177                    fi
178                  done
179                fi
180                if test $coin_skip = yes; then
181                  AC_MSG_RESULT(skipping)
182                elif test -r $srcdir/$9/configure; then
183                  coin_subdirs="$coin_subdirs $9"
184                  AC_MSG_RESULT(yes)
185                  AC_CONFIG_SUBDIRS($9)
186                else
187                  AC_MSG_RESULT(no)
188                fi])
189m4_ifvaln([$10],[AC_MSG_CHECKING(whether directory $10 is available)
190                coin_skip=no
191                if test x"$COIN_SKIP_PROJECTS" != x; then
192                  for dir in $COIN_SKIP_PROJECTS; do
193                    if test $dir = $10; then
194                      coin_skip=yes
195                    fi
196                  done
197                fi
198                if test $coin_skip = yes; then
199                  AC_MSG_RESULT(skipping)
200                elif test -r $srcdir/$10/configure; then
201                  coin_subdirs="$coin_subdirs $10"
202                  AC_MSG_RESULT(yes)
203                  AC_CONFIG_SUBDIRS($10)
204                else
205                  AC_MSG_RESULT(no)
206                fi])
207]) # AC_COIN_MAIN_SUBDIRS
208
209###########################################################################
210#                            COIN_CHECK_FILE                              #
211###########################################################################
212
213# A simple replacement for AC_CHECK_FILE that works for cross compilation
214
215AC_DEFUN([AC_COIN_CHECK_FILE],
216[if test -r $1; then
217  $2
218  :
219else
220  $3
221  :
222fi
223])
224
225###########################################################################
226#                        COIN_THIRDPARTY_SUBDIRS                          #
227###########################################################################
228
229# This macro sets up the recursion into the configure script in a
230# subdirectory for compilation of third party code.  The first
231# argument is just the string that appears in the configure output.
232# The second argument is the directory with the configure script, and
233# the third one is a file that should exists in that directory.  If
234# this file does not exist, we assume that the user has not downloaded
235# the code, and we are not going to compile it
236
237AC_DEFUN([AC_COIN_THIRDPARTY_SUBDIRS],
238[AC_MSG_CHECKING(whether code for third party package $1 is available)
239coin_skip=no
240if test x"$COIN_SKIP_PROJECTS" != x; then
241  for dir in $COIN_SKIP_PROJECTS; do
242    if test $dir = $2; then
243      coin_skip=yes
244    fi
245  done
246fi
247if test $coin_skip = yes; then
248  AC_MSG_RESULT(skipping)
249else
250  coin_tmp=`echo $srcdir/$2/$3`
251  # There is probably a more elegant way to get the first thing out here...
252  for i in $coin_tmp; do
253    coin_tmp2=$i
254    #break 1
255  done
256  if test -r $coin_tmp2; then
257    coin_subdirs="$coin_subdirs $2"
258    AC_MSG_RESULT(yes)
259    AC_CONFIG_SUBDIRS($2)
260  else
261    AC_MSG_RESULT(no)
262  fi
263fi
264]) # AC_COIN_THIRDPARTY_SUBDIRS
265
266###########################################################################
267#                           COIN_CHECK_VPATH                              #
268###########################################################################
269
270# This macro sets the variable coin_vpath_config to true if this is a
271# VPATH configuration, otherwise it sets it to false.
272AC_DEFUN([AC_COIN_CHECK_VPATH],
273[AC_MSG_CHECKING(whether this is a VPATH configuration)
274if test `cd $srcdir; pwd` != `pwd`; then
275  coin_vpath_config=yes;
276else
277  coin_vpath_config=no;
278fi
279AC_MSG_RESULT($coin_vpath_config)
280]) # AC_COIN_CHECK_VPATH
281
282###########################################################################
283#                         COIN_PROJECTDIR_INIT                            #
284###########################################################################
285
286# This macro does everything that is required in the early part in the
287# configure script, such as defining a few variables.  This should only
288# be used in the main directory of a project directory (the one under
289# which src is)
290
291AC_DEFUN([AC_COIN_PROJECTDIR_INIT],
292[# Initialize the ADDLIBS variable
293ADDLIBS="-lm $LIBS"
294AC_SUBST(ADDLIBS)
295
296# As backup, we make sure we don't loose an FLIBS if it has been set
297# by the user
298save_FLIBS="$FLIBS"
299
300# Initialize the FADDLIBS variable (which is to be used with a fortran
301# compiler and will not include FLIBS)
302FADDLIBS="$LIBS"
303AC_SUBST(FADDLIBS)
304
305# A useful makefile conditional that is always false
306AM_CONDITIONAL(ALWAYS_FALSE, false)
307
308# We set the following variable so that we know later in AC_COIN_FINALIZE
309# that we are in a project main directory
310coin_projectdir=yes
311]) # AC_COIN_PROJECTDIR_INIT
312
313###########################################################################
314#                          COIN_DEBUG_COMPILE                             #
315###########################################################################
316
317# enable the configure flags --enable-debug and --enable-debug-prjct
318# (where prcjt is the name of the project in lower case) and set the
319# variable coin_debug_compile to true or false This is used by
320# COIN_PROG_CXX, COIN_PROG_CC and COIN_PROG_F77 to determine the
321# compilation flags.  This macro also makes the switches
322# --with-prjct-verbosity and --with-prjct-checklevel available, which
323# define the preprocessor macros COIN_PRJCT_VERBOSITY and
324# COIN_PRJCT_CHECKLEVEL to the specified value (default is 0).
325#
326# The project specific flags are only made available, if one gives the
327# name of the project as first argument to this macro.
328
329AC_DEFUN([AC_COIN_DEBUG_COMPILE],
330[AC_BEFORE([$0],[AC_COIN_PROG_CXX])dnl
331AC_BEFORE([$0],[AC_COIN_PROG_CC])dnl
332AC_BEFORE([$0],[AC_COIN_PROG_F77])dnl
333
334AC_MSG_CHECKING([whether we want to compile in debug mode])
335
336AC_ARG_ENABLE([debug],
337[AC_HELP_STRING([--enable-debug],
338                [compile all projects with debug options tests])],
339[case "${enableval}" in
340   yes) coin_debug_compile=true
341        if test "${enable_shared+set}" = set; then :; else
342          enable_shared=no
343        fi
344        ;;
345   no)  coin_debug_compile=false
346        ;;
347   *) AC_MSG_ERROR(bad value ${enableval} for --enable-debug)
348        ;;
349esac],
350[coin_debug_compile=false])
351
352m4_ifvaln([$1],
353[AC_ARG_ENABLE(debug-m4_tolower($1),
354 [AC_HELP_STRING([--enable-debug-m4_tolower($1)],
355                 [compile this project ($1) with debug options])],
356 [case "${enableval}" in
357    yes) coin_debug_compile=true
358         enable_shared=no
359         ;;
360    no)  coin_debug_compile=false
361         ;;
362    *) AC_MSG_ERROR(bad value ${enableval} for --enable-debug-m4_tolower($1))
363         ;;
364 esac],[:])
365]) # m4_ifvaln([$1],
366
367if test $coin_debug_compile = true; then
368  AC_MSG_RESULT([yes])
369else
370  AC_MSG_RESULT([no])
371fi
372
373m4_ifvaln([$1],
374[AC_ARG_WITH(m4_tolower($1)-verbosity,
375             AC_HELP_STRING([--with-m4_tolower($1)-verbosity],
376                            [specify the debug verbosity level for project $1]),
377             [if test "$withval" = yes; then
378                withval=1
379              fi
380              m4_tolower(coin_$1_verbosity)=$withval],
381             [m4_tolower(coin_$1_verbosity)=0])
382 AC_DEFINE_UNQUOTED(m4_toupper(COIN_$1_VERBOSITY),
383                    m4_tolower($coin_$1_verbosity),
384                    [Define to the debug verbosity level (0 is no output)])
385
386 AC_ARG_WITH(m4_tolower($1)-checklevel,
387             AC_HELP_STRING([--with-m4_tolower($1)-checklevel],
388                            [specify the sanity check level for project $1]),
389             [if test "$withval" = yes; then
390                withval=1
391              fi
392              m4_tolower(coin_$1_checklevel)=$withval],
393             [m4_tolower(coin_$1_checklevel)=0])
394 AC_DEFINE_UNQUOTED(m4_toupper(COIN_$1_CHECKLEVEL),
395                    m4_tolower($coin_$1_checklevel),
396                    [Define to the debug sanity check level (0 is no test)])
397
398# We use the following variable to have a string with the upper case
399# version of the project name
400COIN_PRJCT=m4_toupper($1)
401
402]) # m4_ifvaln([$1],
403 
404]) # AC_COIN_DEBUG_COMPILE
405
406###########################################################################
407#                          COIN_MINGW_LD_FIX                              #
408###########################################################################
409
410# This macro is included by any PROG_compiler macro, to set the LD
411# environment variable on MinGW to the correct value (link). But note that
412# if we're building in cygwin with -mno-cygwin, we still want ld! If we're
413# building from cygwin with MSVC tools (cl/link), then we do want link and
414# you'd better have your PATH variable straight, else you'll be doing file
415# links instead of code links! Arguably, LDFLAGS should include -mno-cygwin
416# but in practice all linking seems to be handled through the compilers, so
417# CFLAGS and CXXFLAGS suffice.
418
419AC_DEFUN([AC_COIN_MINGW_LD_FIX],
420[case $build in
421  *-mingw*)
422    if test "${LD+set}" = set; then :; else
423      LD=link
424    fi
425    ;;
426 esac
427 case $enable_doscompile in
428   msvc)
429     if test "x${LD+set}" = xset; then :; else
430       LD=link
431     fi
432     ;;
433 esac
434])
435
436###########################################################################
437#                        COIN_ENABLE_DOSCOMPILE                           #
438###########################################################################
439
440# This macro is invoked by any PROG_compiler macro to establish the
441# --enable-doscompile option, used when one wants to compile an executable
442# under Cygwin which also runs directly under DOS (without requiring
443# Cygwin1.dll). The job of this macro is to make sure the option is correct and
444# to set enable_doscompile. Legal values are mingw, msvc, and no (disabled).
445# mingw: Fake mingw under cygwin, using GCC tools and -mno-cygwin. The most
446#        important thing here is that preprocess, compile, and link steps
447#        *all* see -mno-cygwin.
448# msvc:  Assume the presence of cl/link. It's the user's responsibility to
449#        make sure their PATH is correct. In particular, that MSVC link is
450#        found and not cygwin link (we want to do code linking, not file
451#        linking).
452# It's the responsibility of individual PROG_compiler macros to ensure that
453# they correctly set the compiler search list and preprocess, compile, and
454# link flags. This is tied to compiler setup because in practice invocations
455# of the preprocessor and linker are made through the compiler.
456
457AC_DEFUN([AC_COIN_ENABLE_DOSCOMPILE],
458[AC_REQUIRE([AC_CANONICAL_BUILD])
459 AC_ARG_ENABLE([doscompile],
460  [AC_HELP_STRING([--enable-doscompile],
461                  [Under Cygwin, compile so that executables run under DOS.
462                   Set to mingw to use gcc/g++/ld with -mno-cygwin.
463                   Set to msvc to use cl/link (or icl/link).
464                   Default when mentioned: mingw.
465                   Default when not mentioned: disabled.])],
466  [if test "$enable_doscompile" != no; then
467     case $build in
468       *-cygwin* | *-mingw*) ;;
469       *) AC_MSG_ERROR([--enable-doscompile option makes sense only under Cygwin or MinGW]) ;;
470     esac
471   fi],
472  [enable_doscompile=no])
473 case "$enable_doscompile" in
474   mingw)
475     case $build in
476       *-mingw*) enable_doscompile=no ;;
477     esac
478     ;;
479   msvc|no) ;;
480   yes) enable_doscompile=mingw ;;
481   *) AC_MSG_ERROR([Invalid value $enable_doscompile for --enable-doscompile.
482                    Try configure --help=recursive.])
483      ;;
484  esac
485  if test "$enable_doscompile" != no ; then
486    AC_MSG_NOTICE([DOS compile style is: $enable_doscompile])
487  fi
488])
489
490###########################################################################
491#                             COIN_PROG_CXX                               #
492###########################################################################
493
494# Find the compile command by running AC_PROG_CXX (with compiler names for
495# different operating systems) and put it into CXX (unless it was given by the
496# user). Then find an appropriate value for CXXFLAGS. If either of CXXFLAGS or
497# PRJCT_CXXFLAGS is defined, that value is used (replace PRJCT with the upper
498# case name of this project).  It is possible to provide additional -D flags
499# in the variable CXXDEFS, and additional compilation flags with ADD_CXXFLAGS.
500
501AC_DEFUN([AC_COIN_PROG_CXX],
502[AC_REQUIRE([AC_COIN_PROG_CC]) #Let's try if that overcomes configuration problem with VC++ 6.0
503AC_REQUIRE([AC_COIN_ENABLE_DOSCOMPILE])
504AC_LANG_PUSH(C++)
505
506AC_ARG_VAR(CXXDEFS,[Additional -D flags to be used when compiling C++ code.])
507AC_ARG_VAR(ADD_CXXFLAGS,[Additional C++ compiler options])
508AC_ARG_VAR(DBG_CXXFLAGS,[Debug C++ compiler options])
509AC_ARG_VAR(OPT_CXXFLAGS,[Optimize C++ compiler options])
510
511coin_has_cxx=yes
512
513save_cxxflags="$CXXFLAGS"
514# For *-*-solaris*, promote Studio/Workshop compiler to front of list.
515case $build in
516  *-cygwin* | *-mingw*)
517             if test "$enable_doscompile" = msvc ; then
518               comps="icl cl"
519             else
520               comps="g++ cl"
521             fi ;;
522  *-*-solaris*)
523             comps="CC xlC_r aCC g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC" ;;
524  *-darwin*) comps="g++ c++ CC" ;;
525          *) comps="xlC_r aCC CC g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC" ;;
526esac
527
528# We delete the cached value, since the test might not have been
529# performed with our choice of compilers earlier
530$as_unset ac_cv_prog_CXX || test "${ac_cv_prog_CXX+set}" != set || { ac_cv_prog_CXX=; export ac_cv_prog_CXX; }
531# AC_MSG_NOTICE([C++ compiler candidates: $comps])
532AC_PROG_CXX([$comps])
533
534#AC_PROG_CXX sets CXX to g++ if it cannot find a working C++ compiler
535#thus, we test here whether $CXX is actually working
536AC_LANG_PUSH(C++)
537AC_MSG_CHECKING([whether C++ compiler $CXX works]);
538AC_COMPILE_IFELSE(
539  [AC_LANG_PROGRAM(, [int i=0;])],
540  [AC_MSG_RESULT(yes)],
541  [AC_MSG_RESULT(no)
542   AC_MSG_ERROR(failed to find a C++ compiler or C++ compiler $CXX does not work)]
543)
544AC_LANG_POP(C++)
545
546# It seems that we need to cleanup something here for the Windows
547case "$CXX" in
548  cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
549    sed -e 's/^void exit (int);//' confdefs.h >> confdefs.hh
550    mv confdefs.hh confdefs.h
551    ;;
552esac
553
554# Autoconf incorrectly concludes that cl recognises -g. It doesn't.
555case "$CXX" in
556  cl* | */cl* | CL* | */CL* )
557    if test "$ac_cv_prog_cxx_g" = yes ; then
558      ac_cv_prog_cxx_g=no
559      AC_MSG_NOTICE([Overruling autoconf; cl does not recognise -g.])
560    fi ;;
561esac
562CXXFLAGS="$save_cxxflags"
563
564# Check if a project specific CXXFLAGS variable has been set
565if test x$COIN_PRJCT != x; then
566  eval coin_tmp=\${${COIN_PRJCT}_CXXFLAGS+set}
567  if test x$coin_tmp = xset; then
568    eval CXXFLAGS=\${${COIN_PRJCT}_CXXFLAGS}
569  fi
570fi
571
572if test x"$CXXFLAGS" = x; then
573
574# ToDo decide whether we want -DNDEBUG for optimization
575  coin_add_cxxflags=
576  coin_opt_cxxflags=
577  coin_dbg_cxxflags=
578  coin_warn_cxxflags=
579
580  if test "$GXX" = "yes"; then
581    case "$CXX" in
582      icpc* | */icpc*)
583        ;;
584      *)
585# ToDo decide about unroll-loops
586        coin_opt_cxxflags="-O3 -fomit-frame-pointer"
587        coin_add_cxxflags="-pipe"
588        coin_dbg_cxxflags="-g"
589        coin_warn_cxxflags="-Wimplicit -Wparentheses -Wreturn-type -Wcast-qual -Wall -Wpointer-arith -Wwrite-strings -Wconversion -Wno-unknown-pragmas"
590        case $build in
591          *-darwin*)
592            ;;
593          *)
594            coin_warn_cxxflags="-pedantic-errors $coin_warn_cxxflags"
595            ;;
596        esac
597
598        case $enable_doscompile in
599          mingw)
600            CXXFLAGS="-mno-cygwin"
601            AC_TRY_LINK(,[int i=0; i++;],[coin_add_cxxflags="-mno-cygwin $coin_add_cxxflags"])
602            CXXFLAGS=
603          ;;
604        esac
605    esac
606  fi
607
608# Note that we do not need to cover GCC in the following tests.
609
610  if test -z "$coin_opt_cxxflags"; then
611    case $build in
612      *-cygwin* | *-mingw*)
613        case "$CXX" in
614          cl* | */cl* | CL* | */CL*)
615            # The MT and MTd options are mutually exclusive
616            coin_opt_cxxflags='-MT -O2'
617            coin_add_cxxflags='-nologo -EHsc -GR -wd4996 -D_CRT_SECURE_NO_DEPRECATE'
618            coin_dbg_cxxflags='-MTd'
619            ;;
620          icl* | */icl* | ICL* | */ICL*)
621            # The MT and MTd options are mutually exclusive
622            coin_opt_cxxflags='-MT -Ox'
623            coin_add_cxxflags='-nologo -EHsc -GR -D_CRT_SECURE_NO_DEPRECATE'
624            coin_dbg_cxxflags='-MTd -debug'
625            ;;
626        esac
627        ;;
628      *-linux-*)
629        case "$CXX" in
630          icpc* | */icpc*)
631            coin_opt_cxxflags="-O3 -ip -mp1"
632            coin_add_cxxflags=""
633            coin_dbg_cxxflags="-g"
634            # Check if -i_dynamic is necessary (for new glibc library)
635            CXXFLAGS=
636            AC_TRY_LINK(,[int i=0; i++;],[],
637                        [coin_add_cxxflags="-i_dynamic $coin_add_cxxflags"])
638            ;;
639          pgCC* | */pgCC*)
640            coin_opt_cxxflags="-fast"
641            coin_add_cxxflags="-Kieee -pc 64"
642            coin_dbg_cxxflags="-g"
643            ;;
644        esac
645        ;;
646      *-ibm-*)
647        case "$CXX" in
648          xlC* | */xlC* | mpxlC* | */mpxlC*)
649            coin_opt_cxxflags="-O -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
650            coin_add_cxxflags="-bmaxdata:0x80000000 -qrtti=dyna -qsuppress=1500-036 -qsuppress=1500-029 -qsourcetype=c++"
651            coin_dbg_cxxflags="-g"
652            ;;
653        esac
654        ;;
655      *-hp-*)
656        case "$CXX" in
657          aCC* | */aCC* )
658            coin_opt_cxxflags="-O"
659            coin_add_cxxflags="-AA"
660            coin_dbg_cxxflags="-g"
661            ;;
662        esac
663        ;;
664      *-*-solaris*)
665          coin_opt_cxxflags="-O4"
666          coin_dbg_cxxflags="-g"
667        ;;
668    esac
669  fi
670
671# Generic flag settings. If these don't work, add a case above.
672
673  if test "$ac_cv_prog_cxx_g" = yes && test -z "$coin_dbg_cxxflags" ; then
674    coin_dbg_cxxflags="-g"
675  fi
676
677  if test -z "$coin_opt_cxxflags"; then
678    # Try if -O option works if nothing else is set
679    CXXFLAGS=-O
680    AC_TRY_LINK([],[int i=0; i++;],[coin_opt_cxxflags="-O"])
681  fi
682
683  # if PM doesn't want the warning messages, take them out
684  if test x"$coin_skip_warn_cxxflags" = xyes; then
685    coin_warn_cxxflags=
686  fi
687
688# Do final setup of flags based on values determined above.
689
690  if test x${DBG_CXXFLAGS+set} != xset; then
691    DBG_CXXFLAGS="$coin_dbg_cxxflags $coin_add_cxxflags $coin_warn_cxxflags"
692  fi
693  if test x${OPT_CXXFLAGS+set} != xset; then
694    OPT_CXXFLAGS="$coin_opt_cxxflags $coin_add_cxxflags -DNDEBUG $coin_warn_cxxflags"
695  fi
696
697  DBG_CXXFLAGS="$DBG_CXXFLAGS $ADD_CXXFLAGS $CXXDEFS"
698  OPT_CXXFLAGS="$OPT_CXXFLAGS $ADD_CXXFLAGS $CXXDEFS"
699
700  if test "$coin_debug_compile" = "true"; then
701    CXXFLAGS="$DBG_CXXFLAGS"
702  else
703    CXXFLAGS="$OPT_CXXFLAGS"
704  fi
705
706# Handle the case where CXXFLAGS was set externally.
707else
708  CXXFLAGS="$CXXFLAGS $ADD_CXXFLAGS $CXXDEFS"
709  if test x${DBG_CXXFLAGS+set} != xset; then
710    DBG_CXXFLAGS="$CXXFLAGS"
711  fi
712  if test x${OPT_CXXFLAGS+set} != xset; then
713    OPT_CXXFLAGS="$CXXFLAGS"
714  fi
715fi
716
717# If CXXFLAGS contains -mno-cygwin, CPPFLAGS must also have it.
718
719case "$CXXFLAGS" in
720  *-mno-cygwin*)
721    if test x${CPPFLAGS+set} != xset ; then
722      CPPFLAGS="-mno-cygwin"
723    else
724      case "$CPPFLAGS" in
725        *-mno-cygwin*)
726          ;;
727        *)
728          CPPFLAGS="$CPPFLAGS -mno-cygwin"
729          ;;
730      esac
731    fi ;;
732esac
733
734# Try if CXXFLAGS works
735save_CXXFLAGS="$CXXFLAGS"
736AC_TRY_LINK([],[int i=0; i++;],[],[CXXFLAGS=])
737if test -z "$CXXFLAGS"; then
738  AC_MSG_WARN([The flags CXXFLAGS="$save_CXXFLAGS" do not work.  I will now just try '-O', but you might want to set CXXFLAGS manually.])
739  CXXFLAGS='-O'
740  AC_TRY_LINK([],[int i=0; i++;],[],[CXXFLAGS=])
741  if test -z "$CXXFLAGS"; then
742    AC_MSG_WARN([This value for CXXFLAGS does not work.  I will continue with empty CXXFLAGS, but you might want to set CXXFLAGS manually.])
743  fi
744fi
745
746AC_MSG_NOTICE([C++ compiler options are: $CXXFLAGS])
747
748AC_ARG_VAR(MPICXX,[C++ MPI Compiler])
749if test x"$MPICXX" = x; then :; else
750  AC_MSG_NOTICE([Will use MPI C++ compiler $MPICXX])
751  CXX="$MPICXX"
752fi
753
754case "$CXX" in
755  cl* | */cl* | CL* | */CL* )
756    AC_COIN_MINGW_LD_FIX
757    ;;
758esac
759
760AC_LANG_POP(C++)
761]) # AC_COIN_PROG_CXX
762
763
764###########################################################################
765#                             COIN_CXXLIBS                                #
766###########################################################################
767
768# Determine the C++ runtime libraries required for linking a C++ library
769# with a Fortran or C compiler.  The result is available in CXXLIBS.
770
771AC_DEFUN([AC_COIN_CXXLIBS],
772[AC_REQUIRE([AC_PROG_CXX])dnl
773AC_LANG_PUSH(C++)
774AC_ARG_VAR(CXXLIBS,[Libraries necessary for linking C++ code with Fortran compiler])
775if test -z "$CXXLIBS"; then
776  if test "$GXX" = "yes"; then
777    case "$CXX" in
778      icpc* | */icpc*)
779        CXXLIBS="-lstdc++"
780        ;;
781      *)
782        CXXLIBS="-lstdc++ -lm" # -lgcc"
783        ;;
784    esac
785  else
786    case $build in
787     *-mingw32 | *-cygwin* )
788      case "$CXX" in
789      cl* | */cl* | CL* | */CL*)
790        CXXLIBS=nothing;;
791      esac;;
792     *-linux-*)
793      case "$CXX" in
794      icpc* | */icpc*)
795        CXXLIBS="-lstdc++"
796             ;;
797      pgCC* | */pgCC*)
798        CXXLIBS="-lstd -lC -lc"
799             ;;
800      esac;;
801    *-ibm-*)
802      CXXLIBS="-lC -lc"
803      ;;
804    *-hp-*)
805      CXXLIBS="-L/opt/aCC/lib -l++ -lstd_v2 -lCsup_v2 -lm -lcl -lc"
806      ;;
807    *-*-solaris*)
808      CXXLIBS="-lCstd -lCrun"
809    esac
810  fi
811fi
812if test -z "$CXXLIBS"; then
813  AC_MSG_WARN([Could not automatically determine CXXLIBS (C++ link libraries; necessary if main program is in Fortran or C).])
814else
815  AC_MSG_NOTICE([Assuming that CXXLIBS is \"$CXXLIBS\".])
816fi
817if test x"$CXXLIBS" = xnothing; then
818  CXXLIBS=
819fi
820AC_LANG_POP(C++)
821]) # AC_COIN_CXXLIBS
822
823###########################################################################
824#                           COIN_CHECK_HEADER                             #
825###########################################################################
826
827# This macro checks for a header file, but it does so without the
828# standard header.  This avoids warning messages like:
829#
830# configure: WARNING: dlfcn.h: present but cannot be compiled
831# configure: WARNING: dlfcn.h:     check for missing prerequisite headers?
832# configure: WARNING: dlfcn.h: see the Autoconf documentation
833# configure: WARNING: dlfcn.h:     section "Present But Cannot Be Compiled"
834# configure: WARNING: dlfcn.h: proceeding with the preprocessor's result
835# configure: WARNING: dlfcn.h: in the future, the compiler will take precedence
836
837# My guess that the problem lay with CPPFLAGS seems to be correct. With this
838# macro reduced to a direct call to AC_CHECK_HEADERS, there are no warnings
839# now that CPPFLAGS contains -mno-cygwin when it needs it. -- lh, 061214 --
840
841# AW 070609: I restored the previous version, since otherwise the warnings
842# still pop up for the cl compiler
843
844AC_DEFUN([AC_COIN_CHECK_HEADER],
845[#if test x"$4" = x; then
846#  hdr="#include <$1>"
847#else
848#  hdr="$4"
849#fi
850#AC_CHECK_HEADERS([$1],[$2],[$3],[$hdr])
851AC_CHECK_HEADERS([$1],[$2],[$3],[$4])
852]) # AC_COIN_CHECK_HEADER
853
854###########################################################################
855#                       COIN_CHECK_CXX_CHEADER                             #
856###########################################################################
857
858# This macro checks for C header files that are used from C++.  For a give
859# stub (e.g., math), it first checks if the C++ library (cmath) is available.
860# If it is, it defines HAVE_CMATH (or whatever the stub is).  If it is not
861# available, it checks for the old C head (math.h) and defines HAVE_MATH_H
862# if that one exists.
863
864AC_DEFUN([AC_COIN_CHECK_CXX_CHEADER],
865[AC_LANG_PUSH(C++)
866AC_COIN_CHECK_HEADER([c$1],[$2],[$3],[$4])
867if test "$ac_cv_header_c$1" != "yes"; then
868  AC_COIN_CHECK_HEADER([$1.h],[$2],[$3],[$4])
869fi
870AC_LANG_POP(C++)
871]) # AC_COIN_CHECK_CXX_CHEADER
872
873###########################################################################
874#                             COIN_PROG_CC                                #
875###########################################################################
876
877# Find the compile command by running AC_PROG_CC (with compiler names
878# for different operating systems) and put it into CC (unless it was
879# given my the user), and find an appropriate value for CFLAGS.  It is
880# possible to provide additional -D flags in the variable CDEFS.
881
882AC_DEFUN([AC_COIN_PROG_CC],
883[AC_REQUIRE([AC_COIN_MINGW_LD_FIX])
884AC_REQUIRE([AC_COIN_ENABLE_DOSCOMPILE])
885AC_LANG_PUSH(C)
886
887# For consistency, we set the C compiler to the same value of the C++
888# compiler, if the C++ is set, but the C compiler isn't (only for CXX=cl)
889if test x"$CXX" != x; then
890  case "$CXX" in
891    cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
892      if test x"$CC" = x; then
893        CC="$CXX"
894        AC_MSG_WARN([C++ compiler name provided as $CXX, but CC is unset. Setting CC to $CXX])
895      fi
896      ;;
897  esac
898fi
899
900AC_ARG_VAR(CDEFS,[Additional -D flags to be used when compiling C code.])
901AC_ARG_VAR(ADD_CFLAGS,[Additional C compiler options])
902AC_ARG_VAR(DBG_CFLAGS,[Debug C compiler options])
903AC_ARG_VAR(OPT_CFLAGS,[Optimize C compiler options])
904
905coin_has_cc=yes
906
907save_cflags="$CFLAGS"
908
909# For *-*-solaris*, promote Studio/Workshop cc compiler to front of list.
910# Depending on the user's PATH, when Studio/Workshop cc is not present we may
911# find /usr/ucb/cc, which is almost certainly not a good choice for the C
912# compiler. In this case, put cc after gcc.
913
914case $build in
915  *-cygwin* | *-mingw*)
916             if test "$enable_doscompile" = msvc ; then
917               comps="icl cl"
918             else
919               comps="gcc cl"
920             fi ;;
921  *-*-solaris*)
922             AC_CHECK_PROG(sol_cc_compiler,cc,cc,[],[],/usr/ucb/cc)
923             if test "$sol_cc_compiler" = "cc" ; then
924               comps="cc xlc gcc pgcc icc"
925             else
926               comps="xlc gcc pgcc icc cc"
927             fi
928             ;;
929  *-linux-*) comps="xlc gcc cc pgcc icc" ;;
930  *)         comps="xlc_r xlc cc gcc pgcc icc" ;;
931esac
932
933# We delete the cached value, since the test might not have been
934# performed with our choice of compilers earlier
935$as_unset ac_cv_prog_CC || test "${ac_cv_prog_CC+set}" != set || { ac_cv_prog_CC=; export ac_cv_prog_CC; }
936# AC_MSG_NOTICE([C compiler candidates: $comps])
937AC_PROG_CC([$comps])
938if test -z "$CC" ; then
939  AC_MSG_ERROR([Failed to find a C compiler!])
940fi
941# Autoconf incorrectly concludes that cl recognises -g. It doesn't.
942case "$CC" in
943  cl* | */cl* | CL* | */CL* )
944    if test "$ac_cv_prog_cc_g" = yes ; then
945      ac_cv_prog_cc_g=no
946      AC_MSG_NOTICE([Overruling autoconf; cl does not recognise -g.])
947    fi ;;
948esac
949CFLAGS="$save_cflags"
950
951# Check if a project specific CFLAGS variable has been set
952if test x$COIN_PRJCT != x; then
953  eval coin_tmp=\${${COIN_PRJCT}_CFLAGS+set}
954  if test x$coin_tmp = xset; then
955    eval CFLAGS=\${${COIN_PRJCT}_CFLAGS}
956  fi
957fi
958
959if test x"$CFLAGS" = x; then
960
961  coin_add_cflags=
962  coin_opt_cflags=
963  coin_dbg_cflags=
964  coin_warn_cflags=
965
966  if test "$GCC" = "yes"; then
967    case "$CC" in
968      icc* | */icc*)
969        ;;
970      *)
971        coin_opt_cflags="-O3 -fomit-frame-pointer"
972        coin_add_cflags="-pipe"
973        coin_dbg_cflags="-g"
974        coin_warn_cflags="-Wimplicit -Wparentheses -Wsequence-point -Wreturn-type -Wcast-qual -Wall -Wno-unknown-pragmas"
975        case $build in
976          *-darwin*)
977            ;;
978          *)
979            coin_warn_cflags="-pedantic-errors $coin_warn_cflags"
980            ;;
981        esac
982        case $enable_doscompile in
983          mingw)
984            CFLAGS="-mno-cygwin"
985            AC_TRY_LINK([],[int i=0; i++;],
986                        [coin_add_cflags="-mno-cygwin $coin_add_cflags"])
987            CFLAGS=
988          ;;
989        esac
990    esac
991  fi
992  if test -z "$coin_opt_cflags"; then
993    case $build in
994      *-cygwin* | *-mingw*)
995        case "$CC" in
996          cl* | */cl* | CL* | */CL*)
997            coin_opt_cflags='-MT -O2'
998            coin_add_cflags='-nologo -wd4996 -D_CRT_SECURE_NO_DEPRECATE'
999            coin_dbg_cflags='-MTd'
1000            ;;
1001          icl* | */icl* | ICL* | */ICL*)
1002            coin_opt_cflags='-MT -Ox'
1003            coin_add_cflags='-nologo -D_CRT_SECURE_NO_DEPRECATE'
1004            coin_dbg_cflags='-MTd -debug'
1005            ;;
1006        esac
1007        ;;
1008      *-linux-*)
1009        case "$CC" in
1010          icc* | */icc*)
1011            coin_opt_cflags="-O3 -ip -mp1"
1012            coin_add_cflags=""
1013            coin_dbg_cflags="-g"
1014            # Check if -i_dynamic is necessary (for new glibc library)
1015            CFLAGS=
1016            AC_TRY_LINK([],[int i=0; i++;],[],
1017                        [coin_add_cflags="-i_dynamic $coin_add_cflags"])
1018            ;;
1019          pgcc* | */pgcc*)
1020            coin_opt_cflags="-fast"
1021            coin_add_cflags="-Kieee -pc 64"
1022            coin_dbg_cflags="-g"
1023            ;;
1024        esac
1025        ;;
1026      *-ibm-*)
1027        case "$CC" in
1028          xlc* | */xlc* | mpxlc* | */mpxlc*)
1029            coin_opt_cflags="-O -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
1030            coin_add_cflags="-bmaxdata:0x80000000 -qsuppress=1500-036 -qsuppress=1500-029"
1031            coin_dbg_cflags="-g"
1032          ;;
1033        esac
1034        ;;
1035      *-hp-*)
1036        coin_opt_cflags="-O"
1037        coin_add_cflags="-Ae"
1038        coin_dbg_cflags="-g"
1039        ;;
1040      *-*-solaris*)
1041        coin_opt_cflags="-xO4"
1042        coin_dbg_cflags="-g"
1043        ;;
1044      *-sgi-*)
1045        coin_opt_cflags="-O -OPT:Olimit=0"
1046        coin_dbg_cflags="-g"
1047        ;;
1048    esac
1049  fi
1050
1051  if test "$ac_cv_prog_cc_g" = yes && test -z "$coin_dbg_cflags" ; then
1052    coin_dbg_cflags="-g"
1053  fi
1054
1055  if test -z "$coin_opt_cflags"; then
1056    # Try if -O option works if nothing else is set
1057    CFLAGS="-O"
1058    AC_TRY_LINK([],[int i=0; i++;],[coin_opt_cflags="-O"])
1059  fi
1060
1061  # if PM doesn't want the warning messages, take them out
1062  if test x"$coin_skip_warn_cflags" = xyes; then
1063    coin_warn_cflags=
1064  fi
1065
1066  if test x${DBG_CFLAGS+set} != xset; then
1067    DBG_CFLAGS="$coin_dbg_cflags $coin_add_cflags $coin_warn_cflags"
1068  fi
1069  if test x${OPT_CFLAGS+set} != xset; then
1070    OPT_CFLAGS="$coin_opt_cflags $coin_add_cflags -DNDEBUG $coin_warn_cflags"
1071  fi
1072
1073  DBG_CFLAGS="$DBG_CFLAGS $ADD_CFLAGS $CDEFS"
1074  OPT_CFLAGS="$OPT_CFLAGS $ADD_CFLAGS $CDEFS"
1075
1076  if test "$coin_debug_compile" = "true"; then
1077    CFLAGS="$DBG_CFLAGS"
1078  else
1079    CFLAGS="$OPT_CFLAGS"
1080  fi
1081else
1082  CFLAGS="$CFLAGS $ADD_CFLAGS $CDEFS"
1083  if test x${DBG_CFLAGS+set} != xset; then
1084    DBG_CFLAGS="$CFLAGS"
1085  fi
1086  if test x${OPT_CFLAGS+set} != xset; then
1087    OPT_CFLAGS="$CFLAGS"
1088  fi
1089fi
1090
1091# If CFLAGS contains -mno-cygwin, CPPFLAGS must also have it.
1092
1093case "$CFLAGS" in
1094  *-mno-cygwin*)
1095    if test x${CPPFLAGS+set} != xset ; then
1096      CPPFLAGS="-mno-cygwin"
1097    else
1098      case "$CPPFLAGS" in
1099        *-mno-cygwin*)
1100          ;;
1101        *)
1102          CPPFLAGS="$CPPFLAGS -mno-cygwin"
1103          ;;
1104      esac
1105    fi ;;
1106esac
1107
1108# Try if CFLAGS works
1109save_CFLAGS="$CFLAGS"
1110AC_TRY_LINK([],[int i=0; i++;],[],[CFLAGS=])
1111if test -z "$CFLAGS"; then
1112  AC_MSG_WARN([The value CFLAGS="$save_CFLAGS" do not work.  I will now just try '-O', but you might want to set CFLAGS manually.])
1113  CFLAGS='-O'
1114  AC_TRY_LINK([],[int i=0; i++;],[],[CFLAGS=])
1115  if test -z "$CFLAGS"; then
1116    AC_MSG_WARN([This value for CFLAGS does not work.  I will continue with empty CFLAGS, but you might want to set CFLAGS manually.])
1117  fi
1118fi
1119
1120AC_MSG_NOTICE([C compiler options are: $CFLAGS])
1121
1122AC_ARG_VAR(MPICC,[C MPI Compiler])
1123if test x"$MPICC" = x; then :; else
1124  AC_MSG_NOTICE([Will use MPI C compiler $MPICC])
1125  CC="$MPICC"
1126fi
1127
1128# Correct ADDLIBS initialization if we are using the MS compiler
1129case "$CC" in
1130  cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
1131    ADDLIBS=
1132    AC_COIN_MINGW_LD_FIX
1133    ;;
1134esac
1135
1136AC_LANG_POP(C)
1137]) # AC_COIN_PROG_CC
1138
1139###########################################################################
1140#                             COIN_PROG_F77                               #
1141###########################################################################
1142
1143# Find the compile command by running AC_PROG_F77 (with compiler names
1144# for different operating systems) and put it into F77 (unless it was
1145# given by the user), and find an appropriate value for FFLAGS
1146
1147AC_DEFUN([AC_COIN_PROG_F77],
1148[AC_REQUIRE([AC_COIN_MINGW_LD_FIX])
1149AC_REQUIRE([AC_COIN_ENABLE_DOSCOMPILE])
1150AC_REQUIRE([AC_COIN_PROG_CC])
1151AC_REQUIRE([AC_COIN_F77_COMPS])
1152AC_LANG_PUSH([Fortran 77])
1153
1154AC_ARG_VAR(ADD_FFLAGS,[Additional Fortran compiler options])
1155AC_ARG_VAR(DBG_FFLAGS,[Debug Fortran compiler options])
1156AC_ARG_VAR(OPT_FFLAGS,[Optimize Fortran compiler options])
1157
1158coin_has_f77=yes
1159
1160save_fflags="$FFLAGS"
1161
1162# We delete the cached value, since the test might not have been
1163# performed with our choice of compilers earlier
1164$as_unset ac_cv_prog_F77 || test "${ac_cv_prog_F77+set}" != set || { ac_cv_prog_F77=; export ac_cv_prog_F77; }
1165
1166# This is a real belt-and-suspenders approach. AC_COIN_FIND_F77 will use
1167# coin_f77_comps to see if there's a program that matches one of the names.
1168# If there's no such program, F77 = unavailable. If we match the name,
1169# feed AC_PROG_F77 the same search list, just to be sure it's a functioning
1170# compiler.
1171# AC_MSG_NOTICE([Fortran compiler candidates: $coin_f77_comps])
1172AC_COIN_FIND_F77
1173if test "$F77" != "unavailable" ; then
1174  AC_PROG_F77($coin_f77_comps)
1175else
1176  AC_MSG_WARN([Failed to find a Fortran compiler!])
1177fi
1178
1179FFLAGS="$save_fflags"
1180
1181# Check if a project specific FFLAGS variable has been set
1182if test x$COIN_PRJCT != x; then
1183  eval coin_tmp=\${${COIN_PRJCT}_FFLAGS+set}
1184  if test x$coin_tmp = xset; then
1185    eval FFLAGS=\${${COIN_PRJCT}_FFLAGS}
1186  fi
1187fi
1188
1189if test "$F77" != "unavailable" && test x"$FFLAGS" = x ; then
1190
1191  coin_add_fflags=
1192  coin_opt_fflags=
1193  coin_dbg_fflags=
1194  coin_warn_fflags=
1195
1196  if test "$G77" = "yes"; then
1197    coin_opt_fflags="-O3 -fomit-frame-pointer"
1198    coin_add_fflags="-pipe"
1199    coin_dbg_fflags="-g"
1200    case $enable_doscompile in
1201      mingw)
1202        FFLAGS="-mno-cygwin"
1203        AC_TRY_LINK(,[      write(*,*) 'Hello world'],
1204                    [coin_add_fflags="-mno-cygwin $coin_add_fflags"])
1205        FFLAGS=
1206      ;;
1207    esac
1208  else
1209    case $build in
1210      *-cygwin* | *-mingw*)
1211        case $F77 in
1212          ifort* | */ifort* | IFORT* | */IFORT* )
1213            coin_opt_fflags='-MT -O3'
1214            coin_add_fflags='-fpp -nologo'
1215            coin_dbg_fflags='-MTd -debug'
1216          ;;
1217          compile_f2c*)
1218            coin_opt_fflags='-MT -O2'
1219            coin_add_fflags='-nologo -wd4996'
1220            coin_dbg_fflags='-MTd'
1221          ;;
1222        esac
1223        ;;
1224      *-linux-*)
1225        case $F77 in
1226          ifc* | */ifc* | ifort* | */ifort*)
1227            coin_opt_fflags="-O3 -ip"
1228            coin_add_fflags="-cm -w90 -w95"
1229            coin_dbg_fflags="-g -CA -CB -CS"
1230            # Check if -i_dynamic is necessary (for new glibc library)
1231            FFLAGS=
1232            AC_TRY_LINK(,[      write(*,*) 'Hello world'],[],
1233                        [coin_add_fflags="-i_dynamic $coin_add_fflags"])
1234            ;;
1235          pgf77* | */pgf77* | pgf90* | */pgf90*)
1236            coin_opt_fflags="-fast"
1237            coin_add_fflags="-Kieee -pc 64"
1238            coin_dbg_fflags="-g"
1239          ;;
1240        esac
1241        ;;
1242      *-ibm-*)
1243        case "$F77" in
1244          xlf* | */xlf* | mpxlf* | */mpxlf* )
1245            coin_opt_fflags="-O -qarch=auto -qcache=auto -qtune=auto -qmaxmem=-1"
1246            coin_add_fflags="-bmaxdata:0x80000000 -qsuppress=1500-036 -qsuppress=1500-029"
1247            coin_dbg_fflags="-g -C"
1248            ;;
1249        esac
1250        ;;
1251      *-hp-*)
1252        coin_opt_fflags="+O3"
1253        coin_add_fflags="+U77"
1254        coin_dbg_fflags="-C -g"
1255        ;;
1256      *-*-solaris*)
1257        coin_opt_fflags="-O4"
1258        coin_dbg_fflags="-g"
1259        ;;
1260      *-sgi-*)
1261        coin_opt_fflags="-O5 -OPT:Olimit=0"
1262        coin_dbg_fflags="-g"
1263        ;;
1264    esac
1265  fi
1266
1267  if test "$ac_cv_prog_f77_g" = yes && test -z "$coin_dbg_fflags" ; then
1268    coin_dbg_fflags="-g"
1269  fi
1270
1271  if test -z "$coin_opt_fflags"; then
1272    # Try if -O option works if nothing else is set
1273    FFLAGS=-O
1274    AC_TRY_LINK(,[      integer i], [coin_opt_fflags="-O"])
1275  fi
1276
1277  # if PM doesn't want the warning messages, take them out
1278  if test x"$coin_skip_warn_fflags" = xyes; then
1279    coin_warn_fflags=
1280  fi
1281
1282  if test x${DBG_FFLAGS+set} != xset; then
1283    DBG_FFLAGS="$coin_dbg_fflags $coin_add_fflags $coin_warn_fflags"
1284  fi
1285  if test x${OPT_FFLAGS+set} != xset; then
1286    OPT_FFLAGS="$coin_opt_fflags $coin_add_fflags $coin_warn_fflags"
1287  fi
1288
1289  DBG_FFLAGS="$DBG_FFLAGS $ADD_FFLAGS"
1290  OPT_FFLAGS="$OPT_FFLAGS $ADD_FFLAGS"
1291
1292  if test "$coin_debug_compile" = "true"; then
1293    FFLAGS="$DBG_FFLAGS"
1294  else
1295    FFLAGS="$OPT_FFLAGS"
1296  fi
1297else
1298  FFLAGS="$FFLAGS $ADD_FFLAGS"
1299  if test x${DBG_FFLAGS+set} != xset; then
1300    DBG_FFLAGS="$FFLAGS"
1301  fi
1302  if test x${OPT_FFLAGS+set} != xset; then
1303    OPT_FFLAGS="$FFLAGS"
1304  fi
1305fi
1306
1307# If FFLAGS contains -mno-cygwin, CPPFLAGS must have it.
1308case "$FFLAGS" in
1309  *-mno-cygwin*)
1310    if test x${CPPFLAGS+set} != xset ; then
1311      CPPFLAGS="-mno-cygwin"
1312    else
1313      case "$CPPFLAGS" in
1314        *-mno-cygwin*)
1315          ;;
1316        *)
1317          CPPFLAGS="$CPPFLAGS -mno-cygwin"
1318          ;;
1319      esac
1320    fi ;;
1321esac
1322
1323# Try if FFLAGS works
1324if test "$F77" != "unavailable" ; then
1325  AC_TRY_LINK(,[      integer i],[],[FFLAGS=])
1326  if test -z "$FFLAGS"; then
1327    AC_MSG_WARN([The flags FFLAGS="$FFLAGS" do not work.  I will now just try '-O', but you might want to set FFLAGS manually.])
1328    FFLAGS='-O'
1329    AC_TRY_LINK(,[      integer i],[],[FFLAGS=])
1330    if test -z "$FFLAGS"; then
1331      AC_MSG_WARN([This value for FFLAGS does not work.  I will continue with empty FFLAGS, but you might want to set FFLAGS manually.])
1332    fi
1333  fi
1334fi
1335
1336AC_MSG_NOTICE([Fortran compiler options are: $FFLAGS])
1337
1338AC_ARG_VAR(MPIF77,[Fortran MPI Compiler])
1339if test x"$MPIF77" = x; then :; else
1340  AC_MSG_NOTICE([Will use MPI Fortran compiler $MPIF77])
1341  F77="$MPIF77"
1342fi
1343
1344case "$F77" in
1345  ifort* | */ifort* | IFORT* | */IFORT*)
1346    AC_COIN_MINGW_LD_FIX
1347    ;;
1348esac
1349
1350AC_LANG_POP([Fortran 77])
1351]) # AC_COIN_PROG_F77
1352
1353###########################################################################
1354#                           COIN_F77_WRAPPERS                             #
1355###########################################################################
1356
1357# Calls autoconfs AC_F77_WRAPPERS and does additional corrections to FLIBS
1358
1359AC_DEFUN([AC_COIN_F77_WRAPPERS],
1360[AC_BEFORE([AC_COIN_PROG_F77],[$0])dnl
1361AC_BEFORE([AC_PROG_F77],[$0])dnl
1362
1363AC_LANG_PUSH([Fortran 77])
1364
1365AC_F77_WRAPPERS
1366
1367# If FLIBS has been set by the user, we just restore its value here
1368if test x"$save_FLIBS" != x; then
1369  FLIBS="$save_FLIBS"
1370else
1371  # This is to correct a missing exclusion in autoconf 2.59
1372  if test x"$FLIBS" != x; then
1373    my_flibs=
1374    for flag in $FLIBS; do
1375      case $flag in
1376        -lcrt*.o) ;;
1377        -lcygwin) ;;
1378               *) my_flibs="$my_flibs $flag" ;;
1379      esac
1380    done
1381    FLIBS="$my_flibs"
1382  fi
1383
1384  case $build in
1385  # The following is a fix to define FLIBS for ifort on Windows
1386  # In its original version, it linked in libifcorert.lib or libifcorertd.lib on Windows/ifort explicitly.
1387  # However, this seem to create a dependency on libifcorert.dll (or libifcorertd.dll) in the executables.
1388  # This is seem to be unnecessary, libifcorert(d).lib has been removed from the link line.
1389     *-cygwin* | *-mingw*)
1390       case "$F77" in
1391         ifort* | */ifort* | IFORT* | */IFORT*)
1392           FLIBS="-link $LIBS /NODEFAULTLIB:libc.lib"
1393#           if "$coin_debug_compile" = true ; then
1394#             FLIBS="-link $LIBS /NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcmt.lib"
1395#           else
1396#             FLIBS="-link $LIBS /NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcmtd.lib"
1397#           fi
1398           ;;
1399         compile_f2c*)
1400           FLIBS=`$F77 -FLIBS` ;;
1401       esac;;
1402     *-hp-*)
1403         FLIBS="$FLIBS -lm";;
1404     *-ibm-*)
1405         FLIBS=`echo $FLIBS | sed 's/-lc)/-lc/g'` ;;
1406     *-linux-*)
1407       case "$F77" in
1408         pgf77* | */pgf77* | pgf90* | */pgf90*)
1409# ask linker to go through the archives multiple times
1410# (the Fortran compiler seems to do that automatically...
1411           FLIBS="-Wl,--start-group $FLIBS -Wl,--end-group" ;;
1412       esac
1413  esac
1414  ac_cv_f77_libs="$FLIBS"
1415fi
1416
1417AC_LANG_POP([Fortran 77])
1418
1419]) # AC_COIN_F77_WRAPPERS
1420
1421###########################################################################
1422#                             COIN_FIND_F77                               #
1423###########################################################################
1424
1425# Attempt to preempt autoconf by locating an appropriate F77 program. This
1426# macro will not trigger a fatal error if a suitable compiler cannot be
1427# found. It should be called before COIN_PROG_F77 or COIN_TRY_FLINK.
1428
1429AC_DEFUN([AC_COIN_FIND_F77],
1430[AC_REQUIRE([AC_COIN_ENABLE_DOSCOMPILE])
1431AC_REQUIRE([AC_COIN_F77_COMPS])
1432AC_MSG_NOTICE([Trying to determine Fortran compiler name])
1433AC_CHECK_PROGS([F77],[$coin_f77_comps],[unavailable])
1434])
1435
1436# Auxilliary macro to make sure both COIN_PROG_F77 and COIN_FIND_F77 use
1437# the same search lists for compiler names.
1438# For *-*-solaris*, promote Studio/Workshop compilers to front of list.
1439AC_DEFUN([AC_COIN_F77_COMPS],
1440[case $build in
1441  *-cygwin* | *-mingw*)
1442     if test "$enable_doscompile" = msvc ; then
1443       coin_f77_comps="ifort fl32 compile_f2c"
1444     else
1445       coin_f77_comps="gfortran g77 ifort fl32 compile_f2c"
1446     fi ;;
1447  *-*-solaris*)
1448     coin_f77_comps="f95 f90 f77 xlf_r fort77 gfortran g77 pgf90 pgf77 ifort ifc frt af77" ;;
1449  *) coin_f77_comps="xlf_r fort77 gfortran f77 g77 pgf90 pgf77 ifort ifc frt af77" ;;
1450 esac
1451])
1452
1453###########################################################################
1454#                          COIN_INIT_AUTOMAKE                             #
1455###########################################################################
1456
1457# This macro calls the regular INIT_AUTOMAKE and MAINTAINER_MODE
1458# macros, and defines additional variables and makefile conditionals,
1459# that are used in the maintainer parts of the makfile.  It also
1460# checks if the correct versions of the autotools are used.
1461#
1462# This also defines the AC_SUBST variables:
1463# abs_source_dir     absolute path to source code for this package
1464# abs_bin_dir        absolute path to the directory where binaries are
1465#                    going to be installed (prefix/bin)
1466# abs_lib_dir        absolute path to the directory where libraries are
1467#                    going to be installed (prefix/lib)
1468# abs_include_dir    absolute path to the directory where the header files
1469#                    are installed (prefix/include)
1470
1471AC_DEFUN([AC_COIN_INIT_AUTOMAKE],
1472[AC_REQUIRE([AC_PROG_EGREP])
1473
1474# AC_MSG_NOTICE([Beginning automake initialisation.])
1475# Stuff for automake
1476AM_INIT_AUTOMAKE
1477AM_MAINTAINER_MODE
1478
1479coin_have_externals=no
1480if test "$enable_maintainer_mode" = yes; then
1481
1482  # If maintainer mode is chosen, we make sure that the correct versions
1483  # of the tools are used, and that we know where libtool.m4 is (to
1484  # recreate acinclude.m4)
1485
1486  AC_SUBST(LIBTOOLM4)
1487  LIBTOOLM4=
1488  # Normally, $HOME
1489  AUTOTOOLS_DFLT=$HOME
1490
1491  AC_CACHE_CHECK([whether we are using the correct autotools],
1492                 [ac_cv_use_correct_autotools],
1493                 [ac_cv_use_correct_autotools=check])
1494
1495  if test $ac_cv_use_correct_autotools = check; then
1496    ac_cv_use_correct_autotools=yes
1497    # Check if we have autoconf
1498    AC_CHECK_PROG([have_autoconf],[autoconf],[yes],[no])
1499    if test $have_autoconf = no; then
1500      AC_MSG_ERROR([You specified you want to use maintainer mode, but I cannot find autoconf in your path.])
1501    fi
1502
1503    # Check whether autoconf is the correct version
1504    correct_version='2.59'
1505    grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
1506    AC_MSG_CHECKING([whether we are using the correct version ($correct_version) of autoconf])
1507    autoconf --version > confauto.out 2>&1
1508    if $EGREP $grep_version confauto.out >/dev/null 2>&1; then
1509      AC_MSG_RESULT([yes])
1510    else
1511      rm -f confauto.out
1512      AC_MSG_RESULT([no])
1513      AC_MSG_ERROR([You don't have the correct version of autoconf as the first one in your path.])
1514    fi
1515    rm -f confauto.out
1516
1517    # Check if the executable autoconf is picked up from the correct location
1518    AC_MSG_CHECKING([whether autoconf is coming from the correct location])
1519    autoconf_dir=`which autoconf | sed -e 's=/autoconf=='`
1520    autoconf_dir=`cd $autoconf_dir; pwd`
1521    if test x$AUTOTOOLS_DIR = x; then
1522      want_dir=$AUTOTOOLS_DFLT/bin
1523    else
1524      want_dir=$AUTOTOOLS_DIR/bin
1525    fi
1526    if test $autoconf_dir = `cd $want_dir; pwd`; then
1527      AC_MSG_RESULT([yes])
1528    else
1529      rm -f confauto.out
1530      AC_MSG_RESULT([no])
1531      AC_MSG_ERROR([The autoconf executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin.])
1532    fi
1533
1534    # Check if we have automake
1535    AC_CHECK_PROG([have_automake],[automake],[yes],[no])
1536    if test $have_automake = no; then
1537      AC_MSG_ERROR([You specified you want to use maintainer mode, but I cannot find automake in your path.])
1538    fi
1539 
1540    # Check whether automake is the correct version
1541    correct_version='1.9.6'
1542    grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
1543    AC_MSG_CHECKING([whether we are using the correct version ($correct_version) of automake])
1544    automake --version > confauto.out 2>&1
1545    if $EGREP $grep_version confauto.out >/dev/null 2>&1; then
1546      AC_MSG_RESULT([yes])
1547    else
1548      rm -f confauto.out
1549      AC_MSG_RESULT([no])
1550      AC_MSG_ERROR([You don't have the correct version of automake as the first one in your path.])
1551    fi
1552    rm -f confauto.out
1553
1554    # Check if the executable automake is picked up from the correct location
1555    AC_MSG_CHECKING([whether automake is coming from the correct location])
1556    automake_dir=`which automake | sed -e 's=/automake=='`
1557    automake_dir=`cd $automake_dir; pwd`
1558    if test x$AUTOTOOLS_DIR = x; then
1559      want_dir=$AUTOTOOLS_DFLT/bin
1560    else
1561      want_dir=$AUTOTOOLS_DIR/bin
1562    fi
1563    if test $automake_dir = `cd $want_dir; pwd`; then
1564      AC_MSG_RESULT([yes])
1565    else
1566      rm -f confauto.out
1567      AC_MSG_RESULT([no])
1568      AC_MSG_ERROR([The automake executable should be picked up from \$AUTOTOOLS_DFLT/bin or \$AUTOTOOLS_DIR/bin.])
1569    fi
1570
1571    # Check if this is the correct version of libtool (with escaped dots)
1572    if test x$AUTOTOOLS_DIR = x; then
1573      want_dir=$AUTOTOOLS_DFLT/share
1574    else
1575      want_dir=$AUTOTOOLS_DIR/share
1576    fi
1577    correct_version='1.5.22'
1578    grep_version=`echo  $correct_version | sed -e 's/\\./\\\\\\./g'`
1579    AC_COIN_CHECK_FILE([$want_dir/libtool/ltmain.sh],
1580                       [have_ltmain=yes],
1581                       [have_ltmain=no])
1582    AC_MSG_CHECKING([whether we are using the correct version ($correct_version) of libtool.])
1583    if test $have_ltmain = yes; then
1584    if $EGREP $grep_version $want_dir/libtool/ltmain.sh >/dev/null 2>&1; then
1585        AC_MSG_RESULT([yes])
1586      else
1587        AC_MSG_RESULT([no])
1588        AC_MSG_ERROR([You don't have the correct version of libtool.])
1589      fi
1590    else
1591      AC_MSG_RESULT([no])
1592      AC_MSG_ERROR([I cannot find the ltmain.sh file.])
1593    fi
1594  fi
1595
1596  # Check if we can find the libtool file
1597  if test x$AUTOTOOLS_DIR = x; then
1598    want_dir=$AUTOTOOLS_DFLT/share
1599  else
1600    want_dir=$AUTOTOOLS_DIR/share
1601  fi
1602  AC_COIN_CHECK_FILE([$want_dir/aclocal/libtool.m4],
1603                     [LIBTOOLM4="$want_dir/aclocal/libtool.m4"],
1604                     [AC_MSG_ERROR([I cannot find the libtool.m4 file.])])
1605
1606  # Check if we have an Externals file
1607  if test -r $srcdir/Externals; then
1608    coin_have_externals=yes
1609  fi
1610  # Check if subversion is installed and understands https
1611  AC_CHECK_PROG([have_svn],[svn],[yes],[no])
1612  if test x$have_svn = xyes; then
1613    AC_CACHE_CHECK([whether svn understands https],
1614                   [ac_cv_svn_understands_https],
1615                   [svn --version > confauto.out 2>&1
1616                    if $EGREP https confauto.out >/dev/null 2>&1; then
1617                      ac_cv_svn_understands_https=yes
1618                    else
1619                      ac_cv_svn_understands_https=no
1620                      have_svn=no
1621                      ac_cv_prog_have_svn=no
1622                    fi
1623                    rm -f confauto.out])
1624  fi
1625
1626  # Find the location of the BuildTools directory
1627  BUILDTOOLSDIR=
1628  if test -r $srcdir/BuildTools/coin.m4; then
1629    BUILDTOOLSDIR=$srcdir/BuildTools
1630  else
1631    if test -r $srcdir/../BuildTools/coin.m4; then
1632      BUILDTOOLSDIR=$srcdir/../BuildTools
1633    else
1634      if test -r $srcdir/../../BuildTools/coin.m4; then
1635        BUILDTOOLSDIR=$srcdir/../../BuildTools
1636      else
1637        AC_MSG_ERROR(Cannot find the BuildTools directory)
1638      fi
1639    fi
1640  fi
1641  AC_SUBST(BUILDTOOLSDIR)
1642
1643  # The following variable is set to the name of the directory where
1644  # the autotool scripts are located
1645  AC_SUBST(AUX_DIR)
1646  AUX_DIR=$ac_aux_dir
1647fi
1648
1649# helpful variable for the base directory of this package
1650abs_source_dir=`cd $srcdir; pwd`
1651AC_SUBST(abs_source_dir)
1652
1653# Stuff for example Makefiles
1654if test x$prefix = xNONE; then
1655  full_prefix=$ac_default_prefix
1656else
1657  full_prefix=$prefix
1658fi
1659full_prefix=`cd $full_prefix ; pwd`
1660AC_SUBST(abs_lib_dir)
1661abs_lib_dir=$full_prefix/lib
1662AC_SUBST(abs_include_dir)
1663abs_include_dir=$full_prefix/include
1664AC_SUBST(abs_bin_dir)
1665abs_bin_dir=$full_prefix/bin
1666
1667AM_CONDITIONAL(HAVE_EXTERNALS,
1668               test $coin_have_externals = yes && test x$have_svn = xyes)
1669
1670# AC_MSG_NOTICE([End automake initialisation.])
1671
1672]) # AC_COIN_INIT_AUTOMAKE
1673
1674###########################################################################
1675#                          COIN_CREATE_LIBTOOL                            #
1676###########################################################################
1677
1678# This does all the tests necessary to create the libtool script in the
1679# package base directory.  If this is used, then the COIN_INIT_AUTO_TOOLS
1680# test in the subdirectories will be able to skip the libtool tests and
1681# just use the one in the package base directory.
1682
1683m4_define([AC_COIN_CREATE_LIBTOOL],
1684[AC_CANONICAL_BUILD
1685
1686# Check if user wants to produce debugging code
1687AC_COIN_DEBUG_COMPILE
1688
1689# Get the name of the C compiler and appropriate compiler options
1690AC_COIN_PROG_CC
1691
1692# Get the name of the C++ compiler and appropriate compiler options
1693AC_COIN_PROG_CXX
1694
1695# Get the name of the Fortran compiler and appropriate compiler options
1696AC_COIN_PROG_F77
1697
1698# Initialize automake and libtool
1699# AC_MSG_NOTICE([Calling INIT_AUTO_TOOLS from CREATE_LIBTOOL.])
1700AC_COIN_INIT_AUTO_TOOLS
1701# AC_MSG_NOTICE([Finished INIT_AUTO_TOOLS from CREATE_LIBTOOL.])
1702])
1703
1704###########################################################################
1705#                         COIN_INIT_AUTO_TOOLS                            #
1706###########################################################################
1707
1708# Initialize the auto tools automake and libtool, with all
1709# modifications we want for COIN packages.
1710#
1711# RPATH_FLAGS        link flags for hardcoding path to shared objects
1712
1713# This is a trick to have this code before AC_COIN_PROG_LIBTOOL
1714AC_DEFUN([AC_COIN_DISABLE_STATIC],
1715[
1716# Test if force_shared has been set
1717if test "x$1" = xforce_shared; then
1718  if test x$enable_shared = xno; then
1719    AC_MSG_ERROR([Shared libraries are disabled by user, but this is not feasible with the given options])
1720  fi
1721  enable_shared=yes;
1722else
1723  # On Cygwin and AIX, building DLLs doesn't work
1724  case $build in
1725    *-cygwin*)
1726      coin_disable_shared=yes
1727      platform=Cygwin
1728    ;;
1729    *-aix*)
1730      coin_disable_shared=yes
1731      platform=AIX
1732    ;;
1733    *-mingw*)
1734      coin_disable_shared=yes
1735      platform="Msys"
1736#      case "$CXX" in
1737#        cl*)
1738#          coin_disable_shared=yes
1739#          platform="Msys with cl"
1740#      ;;
1741#      esac
1742    ;;
1743  esac
1744fi
1745if test x"$coin_disable_shared" = xyes; then
1746  if test x"$enable_shared" = xyes; then
1747    AC_MSG_WARN([On $platform, shared objects are not supported. I'm disabling your choice.])
1748  fi
1749  enable_shared=no
1750fi
1751# By default, we only want the shared objects to be compiled
1752AC_DISABLE_STATIC
1753])
1754
1755m4_define([AC_COIN_INIT_AUTO_TOOLS],
1756[{AC_BEFORE([AC_COIN_PROG_CXX],[$0])
1757AC_BEFORE([AC_COIN_PROG_CC],[$0])
1758AC_BEFORE([AC_COIN_PROG_F77],[$0])
1759
1760# START
1761AC_COIN_DISABLE_STATIC([$1])
1762
1763# Initialize automake
1764AC_COIN_INIT_AUTOMAKE
1765
1766LIBTOOL=
1767if test -r ../libtool; then
1768  coin_config_dir=..
1769  LIBTOOL='$(SHELL) $(top_builddir)/../libtool'
1770fi
1771if test "x$LIBTOOL" = x; then
1772  if test -r ../../libtool; then
1773    coin_config_dir=../..
1774    LIBTOOL='$(SHELL) $(top_builddir)/../../libtool'
1775  fi
1776fi
1777
1778if test "x$LIBTOOL" = x; then
1779# AC_MSG_NOTICE([Creating libtool script (calling COIN_PROG_LIBTOOL).])
1780  # Stuff for libtool
1781  AC_COIN_PROG_LIBTOOL
1782# AC_MSG_NOTICE([Finished COIN_PROG_LIBTOOL.])
1783  # set RPATH_FLAGS to the compiler link flags required to hardcode location
1784  # of the shared objects
1785  AC_COIN_RPATH_FLAGS($abs_lib_dir)
1786
1787else
1788
1789  AC_MSG_NOTICE([Using libtool script in directory $coin_config_dir])
1790  # get all missing information from the config.log file
1791
1792  # output variables and defines
1793  as_save_IFS=$IFS
1794  IFS='
1795'
1796  for oneline in `cat $coin_config_dir/config.status`; do
1797    case "$oneline" in
1798         # First some automake conditionals
1799      s,@am__fastdep* | s,@AR@* | s,@CPP@*  | s,@CPPFLAGS@* | s,@CXXCPP@*  | \
1800      s,@RANLIB@* | s,@STRIP@* | s,@ac_ct_AR@* | s,@ac_ct_RANLIB@* | \
1801      s,@ac_ct_STRIP@* | s,@host* | s,@LN_S@* | s,@RPATH_FLAGS@* | \
1802      s,@ac_c_preproc_warn_flag@* |  s,@ac_cxx_preproc_warn_flag@* )
1803        command=`echo $oneline | sed -e 's/^s,@//' -e 's/@,/="/' -e 's/,;t t/"/'`
1804#        echo "$command"
1805        eval "$command"
1806        ;;
1807      s,@DEFS@* )
1808        command=`echo $oneline | sed -e 's/^s,@DEFS@,/defsline="/' -e 's/,;t t/"/'`
1809#        echo "$command"
1810        eval "$command"
1811        ;;
1812    esac
1813  done
1814  IFS=$as_save_IFS
1815
1816  # And some defines (assuming here that the packages base dir
1817  # doesn't have a config.h file
1818  for word in $defsline; do
1819#    echo word $word
1820    case $word in
1821      -DHAVE_@<:@A-Z_@:>@*_H=1 | -DSTDC_HEADERS=1 )
1822        i=`echo $word | sed -e 's/-D/#define /' -e 's/=/ /'`
1823#        echo dd $i
1824        echo $i >>confdefs.h
1825        ;;
1826    esac
1827  done
1828fi
1829
1830# AC_MSG_NOTICE([End of INIT_AUTO_TOOLS.])
1831
1832# ToDo
1833# For now, don't use the -no-undefined flag, since the Makefiles are
1834# not yet set up that way.  But we need to fix this, when we want
1835# to comile DLLs under Windows.
1836LT_LDFLAGS=
1837AC_SUBST(LT_LDFLAGS)
1838
1839#END
1840}])
1841
1842
1843###########################################################################
1844#                      COIN_PATCH_LIBTOOL_CYGWIN                          #
1845###########################################################################
1846
1847# Patches to libtool for cygwin. Lots for cl, a few for GCC.
1848# For cl:
1849# - cygpath is not correctly quoted in fix_srcfile_path
1850# - paths generated for .lib files is not run through cygpath -w
1851
1852
1853AC_DEFUN([AC_COIN_PATCH_LIBTOOL_CYGWIN],
1854[ case "$CXX" in
1855    cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
1856      AC_MSG_NOTICE(Applying patches to libtool for cl compiler)
1857      sed -e 's|fix_srcfile_path=\"`cygpath -w \"\$srcfile\"`\"|fix_srcfile_path=\"\\\`'"$CYGPATH_W"' \\\"\\$srcfile\\\"\\\`\"|' \
1858          -e 's|fix_srcfile_path=\"\"|fix_srcfile_path=\"\\\`'"$CYGPATH_W"' \\\"\\$srcfile\\\"\\\`\"|' \
1859          -e 's%compile_deplibs=\"\$dir/\$old_library \$compile_deplibs\"%compile_deplibs="'\`"$CYGPATH_W"' \$dir/\$old_library | sed -e '"'"'sY\\\\\\\\Y/Yg'"'"\`' \$compile_deplibs\"'% \
1860          -e 's%compile_deplibs=\"\$dir/\$linklib \$compile_deplibs\"%compile_deplibs="'\`"$CYGPATH_W"' \$dir/\$linklib | sed -e '"'"'sY\\\\\\\\Y/Yg'"'"\`' \$compile_deplibs\"'% \
1861          -e 's%lib /OUT:%lib -OUT:%' \
1862          -e "s%cygpath -w%$CYGPATH_W%" \
1863          -e 's%$AR x \\$f_ex_an_ar_oldlib%bla=\\`lib -nologo -list \\$f_ex_an_ar_oldlib | xargs echo '"$mydos2unix"'\\`; echo \\$bla; for i in \\$bla; do lib -nologo -extract:\\$i \\$f_ex_an_ar_oldlib; done%' \
1864          -e 's/$AR t/lib -nologo -list/' \
1865          -e 's%f_ex_an_ar_oldlib="\($?*1*\)"%f_ex_an_ar_oldlib='\`"$CYGPATH_W"' \1`%' \
1866          -e 's%^archive_cmds=.*%archive_cmds="\\$CC -o \\$lib \\$libobjs \\$compiler_flags \\\\\\`echo \\\\\\"\\$deplibs\\\\\\" | \\$SED -e '"\'"'s/ -lc\\$//'"\'"'\\\\\\` -link -dll~linknames="%' \
1867          -e 's%old_archive_cmds="lib -OUT:\\$oldlib\\$oldobjs\\$old_deplibs"%old_archive_cmds="if test -r \\$oldlib; then bla=\\"\\$oldlib\\"; else bla=; fi; lib -OUT:\\$oldlib \\\\\\$bla\\$oldobjs\\$old_deplibs"%' \
1868      libtool > conftest.bla
1869
1870      mv conftest.bla libtool
1871      chmod 755 libtool
1872      ;;
1873    *)
1874      AC_MSG_NOTICE(Applying patches to libtool for GNU compiler)
1875      sed -e 's|fix_srcfile_path=\"`cygpath -w \"\$srcfile\"`\"|fix_srcfile_path=\"\\\`'"$CYGPATH_W"' \\\"\\$srcfile\\\"\\\`\"|' \
1876          -e 's|"lib /OUT:\\$oldlib\\$oldobjs\\$old_deplibs"|"\\$AR \\$AR_FLAGS \\$oldlib\\$oldobjs\\$old_deplibs~\\$RANLIB \\$oldlib"|' \
1877          -e 's|libext="lib"|libext="a"|' \
1878      libtool > conftest.bla
1879
1880      mv conftest.bla libtool
1881      chmod 755 libtool
1882      ;;
1883  esac ]) # COIN_PATCH_LIBTOOL_CYGWIN
1884
1885###########################################################################
1886#                    COIN_PATCH_LIBTOOL_SOLARIS                           #
1887###########################################################################
1888# If we want to do a 64-bit build with GCC on Solaris, the system search
1889# libraries need to point to 64-bit subdirectories. If they do not already do
1890# that, fix them. This patch is evolving, as are GCC compilers.  GCC 4.2.1
1891# reports the correct search list, given the correct call. GCC 4.1.1 does not.
1892# `Correct call' means -m64 is specified. `Correct search list' seems to amount
1893# to prepending the list of 64-bit subdirectories to the 32-bit directories.
1894# Both SPARC and x86 have this issue, but a different hardware id string is
1895# required depending on the underlying CPU. The macro executes isainfo to get
1896# the string. This will fail, of course, if we're cross-compiling. The
1897# alternative is to fail on a regular basis each time a new CPU identifier is
1898# needed. This macro will also fail if the search list reported with
1899# -print-search-dirs differs between the C, C++, and Fortran compilers; each
1900# have their own setting in libtool.  If GCC reports the correct search list
1901# given the -m64 flag, the best solution is to define CC='gcc -m64', and
1902# similarly for CXX, F77, so that libtool will make the correct call.
1903###########################################################################
1904AC_DEFUN([AC_COIN_PATCH_LIBTOOL_SOLARIS],
1905[ if test "$GCC" = yes && \
1906     (echo $CXXFLAGS $CFLAGS $FFLAGS | $EGREP 'm64' >/dev/null 2>&1) ; then
1907    hdwisa=`isainfo | sed -e 's/\(@<:@^ @:>@*\) .*$/\1/'`
1908    if `$EGREP 'sys_lib_search_path_spec=' libtool | $EGREP -v $hdwisa >/dev/null 2>&1` ; then
1909      AC_MSG_NOTICE([Applying patches to libtool for 64-bit GCC compilation])
1910      fixlibtmp=`$CC -m64 -print-search-dirs | $EGREP '^libraries:'`
1911      fixlibtmp=`echo $fixlibtmp | sed -e 's/libraries: =//' -e 's/:/ /g'`
1912      if `echo "$fixlibtmp" | $EGREP -v $hdwisa  >/dev/null 2>&1` ; then
1913        # AC_MSG_NOTICE(Compensating for broken gcc)
1914        for lib in $fixlibtmp ; do
1915          if test -d "${lib}${hdwisa}" ; then
1916            syslibpath64="$syslibpath64 ${lib}${hdwisa}/"
1917          fi
1918        done
1919        syslibpath64="${syslibpath64} ${fixlibtmp}"
1920      else
1921        syslibpath64="$fixlibtmp"
1922      fi
1923      sed -e 's|sys_lib_search_path_spec=".*"|sys_lib_search_path_spec="'"$syslibpath64"'"|' libtool > conftest.bla
1924      mv conftest.bla libtool
1925      chmod 755 libtool 
1926    fi
1927    # AC_MSG_NOTICE(Result is )
1928    # $EGREP 'sys_lib_search_path_spec=' libtool
1929  fi ]) # COIN_PATCH_LIBTOOL_SOLARIS
1930
1931###########################################################################
1932#                           COIN_PROG_LIBTOOL                             #
1933###########################################################################
1934
1935# Setup the libtool stuff together with any modifications to make it
1936# work on additional platforms
1937
1938AC_DEFUN([AC_COIN_LIBTOOL_WRAPPER],
1939[AC_BEFORE([AC_COIN_BLA],[$0])
1940AC_PROG_LIBTOOL])
1941
1942AC_DEFUN([AC_COIN_BLA],[echo bla])
1943
1944AC_DEFUN([AC_COIN_PROG_LIBTOOL],
1945[# No longer needed now that CPPFLAGS is correctly set -- lh, 061214 --
1946 # AC_REQUIRE([AC_COIN_DLFCN_H])
1947
1948# NEW: If libtool exists in the directory higher up, we use that one
1949#      instead of creating a new one
1950
1951# It turns out that the code for AC_PROG_LIBTOOL is somehow AC_REQUIRED
1952# out in front of this macro body. You'll notice that LIBTOOL is already
1953# defined here.  We'll have to count on this macro not being called if libtool
1954# already exists, or at least move the libtool fixes outside the conditional.
1955# AC_MSG_NOTICE([Entering coin_prog_libtool, LIBTOOL = "$LIBTOOL".])
1956# This test is therefore removed.  -- lh, 061214 --
1957# if test "x$LIBTOOL" = x; then
1958
1959# AC_MSG_NOTICE([Calling PROG_LIBTOOL.])
1960  AC_PROG_LIBTOOL
1961# AC_MSG_NOTICE([Finished PROG_LIBTOOL.])
1962  AC_SUBST(ac_c_preproc_warn_flag)
1963  AC_SUBST(ac_cxx_preproc_warn_flag)
1964
1965  AC_MSG_NOTICE([Build is "$build".])
1966  mydos2unix='| dos2unix'
1967  case $build in
1968    *-mingw*)
1969      CYGPATH_W=echo
1970      mydos2unix=
1971      ;;
1972  esac
1973
1974  case $build in
1975    # Here we need to check if -m32 is specified.  If so, we need to correct
1976    # sys_lib_search_path_spec
1977    *x86_64-*)
1978      if test "$GCC" = yes && (echo $CXXFLAGS $CFLAGS $FFLAGS | $EGREP 'm32' >& /dev/null); then
1979        AC_MSG_NOTICE(Applying patches to libtool for 32bit compilation)
1980        sed -e 's|sys_lib_search_path_spec=".*"|sys_lib_search_path_spec="/lib /usr/lib"|' libtool > conftest.bla
1981        mv conftest.bla libtool
1982        chmod 755 libtool 
1983      fi
1984      ;;
1985
1986    *-solaris*)
1987      AC_COIN_PATCH_LIBTOOL_SOLARIS
1988      ;;
1989    # Cygwin. Ah, cygwin. Too big and ugly to inline; see the macro.
1990    *-cygwin* | *-mingw*)
1991      AC_COIN_PATCH_LIBTOOL_CYGWIN
1992      ;;
1993    *-darwin*)
1994      AC_MSG_NOTICE(Applying patches to libtool for Darwin)
1995      sed -e 's/verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"/verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"/' \
1996        -e 's/ -dynamiclib / -dynamiclib -single_module /g' \
1997      libtool > conftest.bla
1998
1999      mv conftest.bla libtool
2000      chmod 755 libtool
2001      ;;
2002  esac
2003# This fi matches the commented `if test "x$LIBTOOL" = x;' up at the head of
2004# the macro. -- lh, 061214 --
2005# fi
2006
2007# AC_MSG_NOTICE([End libtool initialisation.])
2008]) # AC_COIN_PROG_LIBTOOL
2009
2010# This is a trick to force the check for the dlfcn header to be done before
2011# the checks for libtool
2012# No longer needed now that CPPFLAGS is correctly set.  -- lh, 061214 --
2013# ACDEFUN([AC_COIN_DLFCN_H],
2014# [AC_LANG_PUSH(C)
2015# AC_COIN_CHECK_HEADER([dlfcn.h])
2016# AC_LANG_POP(C)
2017# ]) # AC_COIN_DLFCN_H
2018
2019###########################################################################
2020#                            COIN_RPATH_FLAGS                             #
2021###########################################################################
2022
2023# This macro, in case shared objects are used, defines a variable
2024# RPATH_FLAGS that can be used by the linker to hardwire the library
2025# search path for the given directories.  This is useful for example
2026# Makefiles
2027
2028AC_DEFUN([AC_COIN_RPATH_FLAGS],
2029[RPATH_FLAGS=
2030
2031if test $enable_shared = yes; then
2032  case $build in
2033    *-linux-*)
2034      if test "$GXX" = "yes"; then
2035        RPATH_FLAGS=
2036        for dir in $1; do
2037          RPATH_FLAGS="$RPATH_FLAGS -Wl,--rpath -Wl,$dir"
2038        done
2039      fi ;;
2040    *-darwin*)
2041        RPATH_FLAGS=nothing ;;
2042    *-ibm-*)
2043      case "$CXX" in
2044      xlC* | */xlC* | mpxlC* | */mpxlC*)
2045        RPATH_FLAGS=nothing ;;
2046      esac ;;
2047    *-hp-*)
2048        RPATH_FLAGS=nothing ;;
2049    *-mingw32)
2050        RPATH_FLAGS=nothing ;;
2051    *-*-solaris*)
2052        RPATH_FLAGS=
2053        for dir in $1; do
2054          RPATH_FLAGS="$RPATH_FLAGS -R$dir"
2055        done
2056  esac
2057
2058  if test "$RPATH_FLAGS" = ""; then
2059    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.])
2060  fi
2061  if test "$RPATH_FLAGS" = "nothing"; then
2062    RPATH_FLAGS=
2063  fi
2064fi
2065
2066AC_SUBST(RPATH_FLAGS)
2067]) # AC_COIN_RPATH_FLAGS
2068
2069###########################################################################
2070#                        COIN_LINK_INPUT_CMD                              #
2071###########################################################################
2072
2073# This macro determines which command should be used to "link" files
2074# that are input to the generated executables.  On Windows, the codes
2075# using the native Windows system libraries, cannot understand symbolic
2076# links, and a copy should be used instead of 'ln -s'.
2077# The result is stored in coin_link_input_cmd
2078
2079AC_DEFUN([AC_COIN_LINK_INPUT_CMD],
2080[AC_REQUIRE([AC_PROG_LN_S])
2081AC_BEFORE([AC_COIN_PROG_CC], [$0])
2082AC_BEFORE([AC_COIN_ENABLE_DOSCOMPILE], [$0])
2083
2084AC_MSG_CHECKING([which command should be used to link input files])
2085coin_link_input_cmd="$LN_S"
2086if test "$enable_doscompile" = mingw; then
2087  coin_link_input_cmd=cp
2088fi
2089case "$CC" in
2090  cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
2091    coin_link_input_cmd=cp ;;
2092esac
2093AC_MSG_RESULT($coin_link_input_cmd)
2094])
2095
2096###########################################################################
2097#                              COIN_FINALIZE                              #
2098###########################################################################
2099
2100# This macro should be called at the very end of the configure.ac file.
2101# It creates the output files (by using AC_OUTPUT), and might do some other
2102# things (such as generating links to data files in a VPATH configuration).
2103# It also prints the "success" message.
2104# Note: If the variable coin_skip_ac_output is set to yes, then no output
2105# files are written.
2106
2107AC_DEFUN([AC_COIN_FINALIZE],
2108[
2109AC_REQUIRE([AC_COIN_LINK_INPUT_CMD])
2110if test x$coin_skip_ac_output != xyes; then
2111
2112  FADDLIBS="$ADDLIBS"
2113  if test x"$coin_need_flibs" = xyes; then
2114    ADDLIBS="$ADDLIBS $FLIBS"
2115  fi
2116
2117  # library extension
2118  AC_SUBST(LIBEXT)
2119  case "$CC" in
2120    cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
2121         LIBEXT=lib ;;
2122      *) LIBEXT=a ;;
2123  esac
2124
2125  # Define VPATH_DISTCLEANFILES to be everything that needs to be
2126  # cleaned for distclean in a vpath configuration
2127  AC_SUBST(VPATH_DISTCLEANFILES)
2128  VPATH_DISTCLEANFILES="$coin_vpath_link_files"
2129
2130  # Take out subdirectories if their configuration concluded that they
2131  # don't need to be compiled
2132  if test x"$coin_ac_skip_subdirs" != x; then
2133    new_subdirs=
2134    for i in $subdirs; do
2135      skipme=no
2136      for j in $coin_ac_skip_subdirs; do
2137        if test $i = $j; then
2138          skipme=yes;
2139        fi
2140      done
2141      if test $skipme = no; then
2142        new_subdirs="$new_subdirs $i"
2143      fi
2144    done
2145    subdirs="$new_subdirs"
2146  fi
2147
2148  AC_OUTPUT
2149
2150  if test x"$coin_vpath_link_files" = x; then : ; else
2151    lnkcmd="$coin_link_input_cmd"
2152    if test "$lnkcmd" = cp; then
2153      AC_MSG_NOTICE(Copying data files for VPATH configuration)
2154    else
2155      AC_MSG_NOTICE(Creating VPATH links for data files)
2156    fi
2157    for file in $coin_vpath_link_files; do
2158      dir=`AS_DIRNAME(["./$file"])`
2159      if test -d $dir; then : ; else
2160        AS_MKDIR_P($dir)
2161      fi
2162      rm -f $file
2163      $lnkcmd $abs_source_dir/$file $file
2164    done
2165  fi
2166
2167  if test x$coin_projectdir = xyes; then
2168    AC_MSG_NOTICE([Configuration of $PACKAGE_NAME successful])
2169  else
2170    AC_MSG_NOTICE([Main configuration of $PACKAGE_NAME successful])
2171  fi
2172else
2173  AC_MSG_NOTICE([No configuration of $PACKAGE_NAME necessary])
2174fi
2175
2176]) #AC_COIN_FINALIZE
2177
2178###########################################################################
2179#                             COIN_VPATH_LINK                             #
2180###########################################################################
2181
2182# This macro makes sure that a symbolic link is created to a file in
2183# the source code directory tree if we are in a VPATH compilation, and
2184# if this package is the main package to be installed
2185
2186AC_DEFUN([AC_COIN_VPATH_LINK],
2187[AC_REQUIRE([AC_COIN_CHECK_VPATH])
2188if test $coin_vpath_config = yes; then
2189  coin_vpath_link_files="$coin_vpath_link_files $1"
2190fi
2191]) #AC_COIN_VPATH_LINK
2192
2193###########################################################################
2194#                       COIN_ENABLE_GNU_PACKAGES                          #
2195###########################################################################
2196
2197# This macro defined the --enable-gnu-packages flag.  This can be used
2198# to check if a user wants to compile GNU packges (such as readline or
2199# zlib) into the executable.  By default, GNU packages are disabled.
2200# This also defines the automake conditional COIN_ENABLE_GNU_PACKAGES
2201
2202AC_DEFUN([AC_COIN_ENABLE_GNU_PACKAGES],
2203[AC_ARG_ENABLE([gnu-packages],
2204               [AC_HELP_STRING([--enable-gnu-packages],
2205                               [compile with GNU packages (disabled by default)])],
2206               [coin_enable_gnu=$enableval],
2207               [coin_enable_gnu=no])
2208]) # AC_COIN_ENABLE_GNU_PACKAGES
2209
2210###########################################################################
2211#                           COIN_CHECK_GNU_ZLIB                           #
2212###########################################################################
2213
2214# This macro checks for the libz library.
2215
2216AC_DEFUN([AC_COIN_CHECK_GNU_ZLIB],
2217[AC_REQUIRE([AC_COIN_ENABLE_GNU_PACKAGES])
2218AC_BEFORE([AC_COIN_PROG_CXX],[$0])
2219AC_BEFORE([AC_COIN_PROG_CC],[$0])
2220AC_BEFORE([AC_COIN_PROG_F77],[$0])
2221AC_BEFORE([$0],[AC_COIN_FINALIZE])
2222
2223coin_has_zlib=no
2224if test $coin_enable_gnu = yes; then
2225  AC_COIN_CHECK_HEADER([zlib.h],[coin_has_zlib=yes])
2226
2227  if test $coin_has_zlib = yes; then
2228    AC_CHECK_LIB([z],[gzopen],
2229                 [ADDLIBS="-lz $ADDLIBS"],
2230                 [coin_has_zlib=no])
2231  fi
2232
2233  if test $coin_has_zlib = yes; then
2234    AC_DEFINE([COIN_HAS_ZLIB],[1],[Define to 1 if zlib is available])
2235  fi
2236fi
2237
2238AM_CONDITIONAL(COIN_HAS_ZLIB,test x$coin_has_zlib = xyes)
2239]) # AC_COIN_CHECK_GNU_ZLIB
2240
2241
2242###########################################################################
2243#                          COIN_CHECK_GNU_BZLIB                           #
2244###########################################################################
2245
2246# This macro checks for the libbz2 library.
2247
2248AC_DEFUN([AC_COIN_CHECK_GNU_BZLIB],
2249[AC_REQUIRE([AC_COIN_ENABLE_GNU_PACKAGES])
2250AC_BEFORE([AC_COIN_PROG_CXX],[$0])
2251AC_BEFORE([AC_COIN_PROG_CC],[$0])
2252AC_BEFORE([AC_COIN_PROG_F77],[$0])
2253AC_BEFORE([$0],[AC_COIN_FINALIZE])
2254
2255coin_has_bzlib=no
2256if test $coin_enable_gnu = yes; then
2257  AC_COIN_CHECK_HEADER([bzlib.h],[coin_has_bzlib=yes])
2258
2259  if test $coin_has_bzlib = yes; then
2260    AC_CHECK_LIB([bz2],[BZ2_bzReadOpen],
2261                 [ADDLIBS="-lbz2 $ADDLIBS"],
2262                 [coin_has_bzlib=no])
2263  fi
2264
2265  if test $coin_has_bzlib = yes; then
2266    AC_DEFINE([COIN_HAS_BZLIB],[1],[Define to 1 if bzlib is available])
2267  fi
2268fi
2269]) # AC_COIN_CHECK_GNU_BZLIB
2270
2271
2272###########################################################################
2273#                         COIN_CHECK_GNU_READLINE                         #
2274###########################################################################
2275
2276# This macro checks for GNU's readline.  It verifies that the header
2277# readline/readline.h is available, and that the -lreadline library
2278# contains "readline".  It is assumed that #include <stdio.h> is included
2279# in the source file before the #include<readline/readline.h>
2280
2281AC_DEFUN([AC_COIN_CHECK_GNU_READLINE],
2282[AC_REQUIRE([AC_COIN_ENABLE_GNU_PACKAGES])
2283AC_BEFORE([AC_COIN_PROG_CXX],[$0])
2284AC_BEFORE([AC_COIN_PROG_CC],[$0])
2285AC_BEFORE([AC_COIN_PROG_F77],[$0])
2286AC_BEFORE([$0],[AC_COIN_FINALIZE])
2287
2288coin_has_readline=no
2289if test $coin_enable_gnu = yes; then
2290  AC_COIN_CHECK_HEADER([readline/readline.h],
2291                       [coin_has_readline=yes],[],
2292                       [#include <stdio.h>])
2293
2294  coin_save_LIBS="$LIBS"
2295  LIBS=
2296  # First we check if tputs and friends are available
2297  if test $coin_has_readline = yes; then
2298    AC_SEARCH_LIBS([tputs],[ncurses termcap curses],[],
2299                   [coin_has_readline=no])
2300  fi
2301
2302  # Now we check for readline
2303  if test $coin_has_readline = yes; then
2304    AC_CHECK_LIB([readline],[readline],
2305                 [ADDLIBS="-lreadline $LIBS $ADDLIBS"],
2306                 [coin_has_readline=no])
2307  fi
2308
2309  if test $coin_has_readline = yes; then
2310    AC_DEFINE([COIN_HAS_READLINE],[1],[Define to 1 if readline is available])
2311  fi
2312
2313  LIBS="$coin_save_LIBS"
2314fi
2315]) # AC_COIN_CHECK_GNU_READLINE
2316
2317###########################################################################
2318#                             COIN_DATA_PATH                              #
2319###########################################################################
2320
2321# This macro defines a preprocessor macro with the absolute path to a
2322# subdirectory of Data.  The argument of this macro is the name of the
2323# subdirectory (in correct case), and the name of the macro is
2324# COIN_DATA_DIR_PATH, where dir is replaced by the capitalized name of
2325# the directory.  The path ends with a separator ("/" for linux and
2326# '\\' for Windows).  The default value for this path can be
2327# overwritten with the input variable with the same name
2328# (COIN_DATA_DIR_PATH).  At this point we chech only for the
2329# $srcdir/../Data subdirectory.
2330
2331AC_DEFUN([AC_COIN_DATA_PATH],
2332[AC_MSG_CHECKING([absolute path to data directory $1])
2333
2334AC_ARG_VAR(m4_toupper(COIN_DATA_$1_PATH),[Set to absolute path to Data/$1 subdirectory])
2335
2336if test x"$m4_toupper(COIN_DATA_$1_PATH)" = x; then
2337  m4_toupper(COIN_DATA_$1_PATH)=`cd $srcdir/../Data/$1; pwd`
2338fi
2339
2340# Under Cygwin, use Windows path.  Add separator
2341case $build in
2342  *-cygwin*)
2343    m4_toupper(COIN_DATA_$1_PATH)=`cygwin -w $m4_toupper(COIN_DATA_$1_PATH)`\\
2344    ;;
2345  *)
2346    m4_toupper(COIN_DATA_$1_PATH)="$m4_toupper(COIN_DATA_$1_PATH)/"
2347    ;;
2348esac
2349
2350if test -r $m4_toupper(COIN_DATA_$1_PATH); then
2351  AC_DEFINE_UNQUOTED(m4_toupper(COIN_DATA_$1_PATH),["$m4_toupper(COIN_DATA_$1_PATH)"],
2352            [Define to absolute path for Data subdirectory $1])
2353  AC_MSG_RESULT($m4_toupper(COIN_DATA_$1_PATH))
2354else
2355  AC_MSG_ERROR(Directory $m4_toupper(COIN_DATA_$1_PATH) does not exist)
2356fi
2357]) # AC_COIN_HAS_DATA
2358
2359###########################################################################
2360#                       COIN_LINK_FROM_FILELIST                           #
2361###########################################################################
2362
2363# This macro creates links (or copies, if necessary) to files listed
2364# as content in a text file (second argument) into a target directory
2365# (first argument), which is created if it doesn't exist yet.  If s link
2366# already exists, nothing happens.
2367
2368AC_DEFUN([AC_COIN_LINKCOPY_FROM_FILELIST],
2369[cmd="$3"
2370if test -e $srcdir/$2 ; then
2371  my_target_dir="$1"
2372  my_link_files=`cat $srcdir/$2`
2373  my_dirname=`AS_DIRNAME($2)`
2374#  if test -e $my_target_dir; then : ; else
2375#    AS_MKDIR_P($my_target_dir)
2376#  fi
2377  for i in $my_link_files; do
2378    #rm -rf $my_target_dir/$i
2379    if test -e $my_target_dir/$i; then : ; else
2380      dirn2=`AS_DIRNAME($my_target_dir/$i)`
2381      if test -e $dirn2; then : ; else
2382        AS_MKDIR_P($dirn2)
2383      fi
2384      $cmd $abs_source_dir/$my_dirname/$i $my_target_dir/$i
2385    fi
2386  done
2387else
2388  AC_MSG_WARN([File list file $2 missing!])
2389fi
2390])
2391
2392AC_DEFUN([AC_COIN_LINK_FROM_FILELIST],
2393[
2394AC_REQUIRE([AC_COIN_LINK_INPUT_CMD])
2395echo Creating links in $1 ...
2396AC_COIN_LINKCOPY_FROM_FILELIST($1, $2, $coin_link_input_cmd)
2397])
2398
2399###########################################################################
2400#                       COIN_COPY_FROM_FILELIST                           #
2401###########################################################################
2402
2403# Like COIN_LINK_FROM_FILELIST, but copies the files.
2404
2405AC_DEFUN([AC_COIN_COPY_FROM_FILELIST],
2406[
2407echo Creating copies in $1 ...
2408AC_COIN_LINKCOPY_FROM_FILELIST($1, $2, [cp])
2409])
2410
2411###########################################################################
2412#                          COIN_EXAMPLE_FILES                             #
2413###########################################################################
2414
2415# This macro determines the names of the example files (using the
2416# argument in an "ls" command) and sets up the variables EXAMPLE_FILES
2417# and EXAMPLE_CLEAN_FILES.  If this is a VPATH configuration, it also
2418# creates soft links to the example files.
2419
2420AC_DEFUN([AC_COIN_EXAMPLE_FILES],
2421[AC_REQUIRE([AC_COIN_CHECK_GNU_ZLIB])
2422AC_REQUIRE([AC_COIN_CHECK_VPATH])
2423files=`cd $srcdir; ls $1`
2424# We need to do the following loop to make sure that are no newlines
2425# in the variable
2426for file in $files; do
2427  EXAMPLE_FILES="$EXAMPLE_FILES $file"
2428done
2429if test $coin_vpath_config = yes; then
2430  lnkcmd=
2431  if test "$enable_doscompile" != no; then
2432    lnkcmd=cp
2433  fi
2434  case "$CC" in
2435    cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
2436      lnkcmd=cp ;;
2437  esac
2438  if test "$lnkcmd" = cp; then
2439    AC_MSG_NOTICE([Copying example files ($1)])
2440  else
2441    AC_PROG_LN_S
2442    AC_MSG_NOTICE([Creating links to the example files ($1)])
2443    lnkcmd="$LN_S"
2444  fi
2445  for file in $EXAMPLE_FILES; do
2446    rm -f $file
2447    $lnkcmd $srcdir/$file $file
2448  done
2449  EXAMPLE_CLEAN_FILES="$EXAMPLE_CLEAN_FILES $1"
2450else
2451  EXAMPLE_CLEAN_FILES="$EXAMPLE_CLEAN_FILES"
2452fi
2453
2454# In case there are compressed files, we create a variable with the
2455# uncompressed names
2456EXAMPLE_UNCOMPRESSED_FILES=
2457for file in $EXAMPLE_FILES; do
2458  case $file in
2459    *.gz)
2460      EXAMPLE_UNCOMPRESSED_FILES="$EXAMPLE_UNCOMPRESSED_FILES `echo $file | sed -e s/.gz//`"
2461      ;;
2462  esac
2463done
2464
2465AC_SUBST(EXAMPLE_UNCOMPRESSED_FILES)
2466AC_SUBST(EXAMPLE_FILES)
2467AC_SUBST(EXAMPLE_CLEAN_FILES)
2468]) #AC_COIN_EXAMPLE_FILES
2469
2470###########################################################################
2471#                            COIN_HAS_PROJECT                             #
2472###########################################################################
2473
2474# This macro sets up usage of a Coin package.  It defines the
2475# PKGSRCDIR and PKGOBJDIR variables, refering to the main source and
2476# object directory of the package, respectively.  It also defines
2477# a COIN_HAS_PKG preprocessor macro and makefile conditional.  The
2478# argument should be the name (Pkg) of the project (in correct lower
2479# and upper case)
2480
2481AC_DEFUN([AC_COIN_HAS_PROJECT],
2482[AC_MSG_CHECKING([for COIN project $1])
2483
2484# First check, if the sub-project is actually available (ToDo: allow
2485# other locations)
2486
2487m4_tolower(coin_has_$1)=unavailable
2488if test x"$COIN_SKIP_PROJECTS" != x; then
2489  for dir in $COIN_SKIP_PROJECTS; do
2490    if test $dir = $1; then
2491      m4_tolower(coin_has_$1)=skipping
2492    fi
2493  done
2494fi
2495
2496if test $m4_tolower(coin_has_$1) != skipping; then
2497  if test $PACKAGE_TARNAME = m4_tolower($1); then
2498    m4_tolower(coin_has_$1)=.
2499  else
2500    if test -d $srcdir/../$1; then
2501      m4_tolower(coin_has_$1)=../$1
2502    fi
2503  fi
2504fi
2505
2506if test $m4_tolower(coin_has_$1) != unavailable &&
2507   test $m4_tolower(coin_has_$1) != skipping; then
2508  # Set the #define if the component is available
2509  AC_DEFINE(m4_toupper(COIN_HAS_$1),[1],[Define to 1 if the $1 package is used])
2510
2511  # Set the variables for source and object code location
2512  AC_SUBST(m4_toupper($1SRCDIR))
2513  m4_toupper($1SRCDIR)=`cd $srcdir/$m4_tolower(coin_has_$1); pwd`
2514  AC_SUBST(m4_toupper($1OBJDIR))
2515  m4_toupper($1OBJDIR)=`pwd`/$m4_tolower(coin_has_$1)
2516  AC_SUBST(m4_toupper($1DOCDIR))
2517  m4_toupper($1DOCDIR)=$abs_lib_dir/../share/doc/coin/$1
2518fi
2519
2520  # Define the Makefile conditional
2521AM_CONDITIONAL(m4_toupper(COIN_HAS_$1),
2522               [test $m4_tolower(coin_has_$1) != unavailable &&
2523                test $m4_tolower(coin_has_$1) != skipping])
2524AC_MSG_RESULT([$m4_tolower(coin_has_$1)])
2525]) # AC_COIN_HAS_PROJECT
2526
2527###########################################################################
2528#                        COIN_HAS_USER_LIBRARY                            #
2529###########################################################################
2530# This macro sets up usage of a user library with header files. The assumption
2531# is that the header file(s) and library do not reside in standard system
2532# directories, hence both the include directory and link flags must be
2533# specified. There are two mandatory arguments and two optional arguments.
2534#
2535# The first argument (mandatory) should be a name (LibraryName) for the
2536# library.  The second argument (mandatory) should be an abbreviation in
2537# upper case letters (LBRY) for the library. Ultimately, the macro will
2538# specify two variables, LBRYINCDIR and LBRYLIB, to be substituted in files
2539# generated during configuration; a preprocessor symbol COIN_HAS_LBRY; and a
2540# matching automake conditional COIN_HAS_LBRY. LBRYINCDIR should specify the
2541# directory containing include files for the library. LBRYLIB should specify
2542# the flags necessary to link to the library. A variable coin_has_lbry will
2543# be set to true or false, as appropriate. A variable lbry_libcheck will be
2544# be set to yes or no; no indicates link checks should not be attempted.
2545#
2546# The macro defines three configure arguments, --with-libraryname-incdir,
2547# --with-libraryname-lib, and --disable-libraryname-libcheck, by converting
2548# LibraryName to lower case.
2549#
2550# LBRYINCDIR and LBRYLIB can be specified as environment variables or as
2551# part of the configure command using --with-libraryname-incdir and
2552# --with-libraryname-lib, respectively. Command line arguments override
2553# environment variables.
2554#
2555# If a third argument is given, it should specify a file in LBRYINCDIR.  The
2556# macro will check for the presence of the file. If a fourth argument is given,
2557# it should specify a function name, `fname'.  The macro will attempt to link a
2558# trivial program containing a parameterless call to the function, `fname()',
2559# using the LBRYLIB flags. The link check uses C as the language; this has been
2560# adequate to date but has limitations. It is possible to disable the link
2561# check by specifying --disable-libraryname-libcheck. This is a workaround for
2562# instances where the link check does not work properly, for whatever reason.
2563# If you're trying to link to a Fortran library, consider using F77_FUNC or
2564# FC_FUNC to obtain a mangled fname appropriate for use from C code. For a C++
2565# library, you're on your own unless the library declares some function with
2566# extern "C" linkage. Otherwise, you'll have to somehow find the mangled C++
2567# name.
2568
2569AC_DEFUN([AC_COIN_HAS_USER_LIBRARY],
2570[ AC_REQUIRE([AC_COIN_PROJECTDIR_INIT])
2571  AC_MSG_CHECKING(if user provides library for $1)
2572
2573# Check for header file directory
2574
2575  AC_ARG_WITH(m4_tolower($1)-incdir,
2576      AS_HELP_STRING([--with-m4_tolower($1)-incdir],
2577                     [specify the header file directory for library $1]),
2578      [$2INCDIR=`cd $withval; pwd`])
2579
2580# Check for library directory
2581
2582  AC_ARG_WITH(m4_tolower($1)-lib,
2583      AS_HELP_STRING([--with-m4_tolower($1)-lib],
2584                     [specify the flags used to link with the library $1]),
2585      [$2LIB=$withval])
2586
2587# Switch to disable library check if requested
2588
2589  AC_ARG_ENABLE(m4_tolower($1)-libcheck,
2590      AS_HELP_STRING([--enable-m4_tolower($1)-libcheck],
2591                     [use disable-m4_tolower($1)-libcheck to skip the link
2592                      check at configuration time]),
2593      [m4_tolower($1)_libcheck=$enableval],
2594      [m4_tolower($1)_libcheck=yes])
2595
2596# At this point, if we're going to use the library, both LBRYINCDIR and
2597# LBRYLIB must be defined and not empty.
2598
2599  if test x"$$2INCDIR" != x || test x"$$2LIB" != x; then
2600    if test x"$$2INCDIR" = x || test x"$$2LIB" = x; then
2601      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.])
2602    fi
2603    m4_tolower(coin_has_$2)=true
2604    AC_MSG_RESULT(yes)
2605  else
2606    m4_tolower(coin_has_$2)=false
2607    AC_MSG_RESULT(no)
2608  fi
2609
2610# If we have instructions for use, consider header and link checks.
2611
2612  if test $m4_tolower(coin_has_$2) = true; then
2613
2614# If argument 3 (file) is given, check for the file. Typically this will be a
2615# header file, but that's not assumed.
2616
2617    m4_ifval([$3],
2618        [AC_COIN_CHECK_FILE([$$2INCDIR/$3],[],
2619             [AC_MSG_ERROR([Cannot find file $3 in $$2INCDIR])])])
2620
2621# Now see if we can link the function. There are arguments for and against
2622# assuming argument 3 is a header file declaring the function. A correct
2623# function declaration is the main argument in favour. Having to cope with
2624# possible dependencies or other oddities are the main arguments against.
2625# Force the use of C as the best single choice amongst C++, C, and Fortran.
2626# Obviously, this has limits.
2627
2628    m4_ifvaln([$4],
2629        [if test x"$m4_tolower($1)_libcheck" != xno; then
2630           coin_save_LIBS="$LIBS"
2631           LIBS="$$2LIB $ADDLIBS"
2632           coin_$2_link=no
2633           AC_LANG_PUSH(C)
2634           for fnm in $4 ; do
2635             AC_MSG_CHECKING([whether symbol $fnm is available with $2])
2636             AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[$fnm()]])],
2637                 [AC_MSG_RESULT(yes)
2638                  coin_$2_link=yes
2639                  break],
2640                 [AC_MSG_RESULT(no)])
2641           done
2642           AC_LANG_POP(C)
2643           if test x"$coin_$2_link" = xyes ; then
2644             LIBS="$coin_save_LIBS"
2645           else
2646             AC_MSG_ERROR([Cannot find symbol(s) $4 with $2])
2647           fi
2648         fi])
2649
2650# If we make it this far, we've verified the file and linked the function. Add
2651# the necessary link flags to ADDLIBS and define the preprocessor symbol
2652# COIN_HAS_LBRY.
2653
2654    ADDLIBS="$$2LIB $ADDLIBS"
2655    AC_DEFINE(COIN_HAS_$2,[1],[Define to 1 if the $1 package is available])
2656  fi
2657
2658# Arrange for configure to substitute LBRYINCDIR and LBRYLIB and create the
2659# automake conditional. These actions must occur unconditionally.
2660
2661  AC_SUBST($2INCDIR)
2662  AC_SUBST($2LIB)
2663  AM_CONDITIONAL(COIN_HAS_$2, test $m4_tolower(coin_has_$2) = true)
2664]) #AC_COIN_HAS_USER_LIBRARY
2665
2666###########################################################################
2667#                               COIN_HAS_ASL                              #
2668###########################################################################
2669
2670# This macro checks if the user has provide arguments that say where
2671# the precompiled ASL files should be found (with the --with-asldir
2672# flag).  If this is not the case, we check if the ThirdParty/ASL
2673# directory has been configured, which indicates that the files will
2674# be in that directory and can be used.
2675
2676AC_DEFUN([AC_COIN_HAS_ASL],
2677[coin_aslobjdir=../ThirdParty/ASL
2678coin_aslsrcdir=$srcdir/$coin_aslobjdir
2679
2680# Determine the name of the ASL library
2681case "$CC" in
2682  cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
2683    ampllib=amplsolv.lib ;;
2684  *)
2685    ampllib=amplsolver.a ;;
2686esac
2687
2688AC_ARG_WITH([asldir],
2689            AC_HELP_STRING([--with-asldir],
2690                           [specify path to AMPL solver directory (or BUILD for compilation, or "no" for disabling AMPL)]),
2691            [use_asldir=$withval], [use_asldir=])
2692
2693if test "$use_asldir" = BUILD; then
2694  if test "$PACKAGE_NAME" != ThirdPartyASL; then
2695    # If we are configuring ThirdParty/ASL, don't check
2696    if test -r $coin_aslobjdir/.MakeOk; then :; else
2697      AC_MSG_ERROR([option \"BUILD\" specified for asldir, but directory is not configure (sources missing?)])
2698    fi
2699  fi
2700elif test -z "$use_asldir"; then
2701 # try to find sources - if not given don't compile
2702  if test "$PACKAGE_NAME" != ThirdPartyASL; then
2703    if test -r $coin_aslobjdir/.MakeOk; then
2704      use_asldir=BUILD
2705    else
2706      use_asldir=no
2707    fi
2708  else
2709    use_asldir=no
2710  fi
2711elif test "$use_asldir" != "no"; then
2712  AC_COIN_CHECK_FILE([$use_asldir/$ampllib],[],
2713                     [AC_MSG_ERROR([ASL directory \"$use_asldir\" specified, but library missing])])
2714  AC_COIN_CHECK_FILE([$use_asldir/asl.h],[],
2715                     [AC_MSG_ERROR([ASL directory \"$use_asldir\" specified, but header files are missing])])
2716  use_asldir=`cd $use_asldir; pwd`
2717  case $build in
2718    *-cygwin*) use_asldir=`cygpath -w $use_asldir | sed -e sX\\\\\\\\X/Xg` ;;
2719  esac
2720fi
2721
2722# Variable containing ASL library (including full path)
2723AC_SUBST(ASLLIB)
2724# Variable containing flags for including ASL header files
2725AC_SUBST(ASL_CPPFLAGS)
2726
2727if test "$use_asldir" = BUILD; then
2728  coin_aslobjdir=`cd $coin_aslobjdir; pwd`
2729  ASLLIB=`$CYGPATH_W $coin_aslobjdir/$ampllib | sed -e sX\\\\\\\\X/Xg`
2730  coin_aslsrcdir=`cd $coin_aslsrcdir; pwd`
2731  ASL_CPPFLAGS="-I"`$CYGPATH_W $coin_aslobjdir | sed -e sX\\\\\\\\X/Xg`" -I"`$CYGPATH_W $coin_aslsrcdir/solvers | sed -e sX\\\\\\\\X/Xg`
2732elif test "$use_asldir" != no; then
2733  ASLLIB=`$CYGPATH_W $use_asldir/$ampllib | sed -e sX\\\\\\\\X/Xg`
2734  ASL_CPPFLAGS="-I"`$CYGPATH_W $use_asldir | sed -e sX\\\\\\\\X/Xg`
2735fi
2736
2737if test "$use_asldir" != no; then
2738  AC_LANG_PUSH(C)
2739  AC_CHECK_LIB(dl,[dlopen],[ASLLIB="$ASLLIB -ldl"],[])
2740  coin_has_asl=yes
2741  AC_DEFINE([COIN_HAS_ASL],[1],
2742            [If defined, the Ampl Solver Library is available.])
2743  AC_LANG_POP(C)
2744else
2745  coin_has_asl=no
2746fi
2747AM_CONDITIONAL(COIN_HAS_ASL, test $coin_has_asl = yes)
2748]) # AC_COIN_HAS_ASL
2749
2750###########################################################################
2751#                            COIN_TRY_FLINK                               #
2752###########################################################################
2753
2754# Auxilliary macro to test if a Fortran function name can be linked,
2755# given the current settings of LIBS.  We determine from the context, what
2756# the currently active programming language is, and cast the name accordingly.
2757# The first argument is the name of the function/subroutine, in small letters,
2758# the second argument are the actions taken when the test works, and the
2759# third argument are the actions taken if the test fails.
2760
2761AC_DEFUN([AC_COIN_TRY_FLINK],
2762[case $ac_ext in
2763  f)
2764    AC_TRY_LINK(,[      call $1],[$2],[$3])
2765    ;;
2766  c)
2767    AC_F77_FUNC($1,cfunc$1)
2768    if test x"$coin_need_flibs" = xyes; then
2769      flink_try=no;
2770    else
2771      AC_TRY_LINK([void $cfunc$1();],[$cfunc$1()],
2772                  [flink_try=yes],[flink_try=no])
2773    fi
2774    if test $flink_try = yes; then
2775      $2
2776    else
2777      if test x"$FLIBS" != x; then
2778        flink_save_libs="$LIBS"
2779        LIBS="$LIBS $FLIBS"
2780        AC_TRY_LINK([void $cfunc$1();],[$cfunc$1()],
2781                    [LIBS="$flink_save_libs"
2782                     $2
2783                     coin_need_flibs=yes],
2784                    [LIBS="$flink_save_libs"
2785                     $3])
2786      else
2787        $3
2788      fi
2789    fi
2790    ;;
2791  cc|cpp)
2792    AC_F77_FUNC($1,cfunc$1)
2793    if test x"$coin_need_flibs" = xyes; then
2794      flink_try=no;
2795    else
2796      AC_TRY_LINK([extern "C" {void $cfunc$1();}],[$cfunc$1()],
2797                  [flink_try=yes],[flink_try=no])
2798    fi
2799    if test $flink_try = yes; then
2800      $2
2801    else
2802      if test x"$FLIBS" != x; then
2803        flink_save_libs="$LIBS"
2804        LIBS="$LIBS $FLIBS"
2805        AC_TRY_LINK([extern "C" {void $cfunc$1();}],[$cfunc$1()],
2806                    [LIBS="$flink_save_libs"
2807                     $2
2808                     coin_need_flibs=yes],
2809                    [LIBS="$flink_save_libs"
2810                     $3])
2811      else
2812        $3
2813      fi
2814    fi
2815    ;;
2816esac
2817]) # AC_COIN_TRY_FLINK
2818
2819###########################################################################
2820#                             COIN_HAS_BLAS                               #
2821###########################################################################
2822
2823# This macro checks for a library containing the BLAS library.  It
2824# tries standard libraries, and if none is found to be working, it
2825# checks whether the BLAS ThirdParty/Blas directory has been configured.
2826# It adds to ADDLIBS any flags required to link with an externally provided
2827# BLAS.  It defines the makefile conditional and preprocessor macro
2828# COIN_HAS_BLAS, if blas is available, and it defines the makefile conditional
2829# COIN_BUILD_BLAS, if blas is compiled within COIN.
2830
2831AC_DEFUN([AC_COIN_HAS_BLAS],
2832[if test "$PACKAGE_NAME" = ThirdPartyBlas || test "$PACKAGE_NAME" = ThirdPartyLapack || test "$PACKAGE_NAME" = ThirdPartyMumps; then
2833  coin_blasobjdir=../Blas
2834else
2835  coin_blasobjdir=../ThirdParty/Blas
2836fi
2837coin_blassrcdir=$srcdir/$coin_blasobjdir
2838
2839AC_ARG_WITH([blas],
2840            AC_HELP_STRING([--with-blas],
2841                           [specify BLAS library (or BUILD for compilation)]),
2842            [use_blas=$withval], [use_blas=])
2843
2844MAKEOKFILE=.MakeOk
2845# Check if user supplied option makes sense
2846if test x"$use_blas" != x; then
2847  if test "$use_blas" = "BUILD"; then
2848    # Don't check for course code if this is executed in ThirdParty/Blas
2849    if test "$PACKAGE_NAME" != ThirdPartyBlas; then
2850      if test -r $coin_blasobjdir/.MakeOk; then :; else
2851        AC_MSG_ERROR([option \"BUILD\" specified for Blas, but $coin_blasobjdir directory is not properly configured])
2852      fi
2853    fi
2854  elif test "$use_blas" != no ; then
2855    AC_MSG_CHECKING([whether user supplied BLASLIB=\"$use_blas\" works])
2856    LIBS="$use_blas $LIBS"
2857    ADDLIBS="$use_blas $ADDLIBS"
2858    AC_COIN_TRY_FLINK([daxpy],
2859                      [AC_MSG_RESULT([yes])],
2860                      [AC_MSG_RESULT([no])
2861                       AC_MSG_ERROR([user supplied BLAS library \"$use_blas\" does not work])])
2862  fi
2863else
2864# Try to autodetect the library for blas based on build system
2865  #AC_MSG_CHECKING([default locations for BLAS])
2866  skip_lblas_check=no
2867  case $build in
2868    *-sgi-*)
2869      SAVE_LIBS="$LIBS"
2870      AC_MSG_CHECKING([whether -lcomplib.sgimath has BLAS])
2871      LIBS="-lcomplib.sgimath $LIBS"
2872      AC_COIN_TRY_FLINK([daxpy],
2873                        [AC_MSG_RESULT([yes])
2874                         use_blas=-lcomplib.sgimath;
2875                         ADDLIBS="-lcomplib.sgimath $ADDLIBS"],
2876                        [AC_MSG_RESULT([no])
2877                         SAVE_LIBS="$LIBS"])
2878      ;;
2879
2880# Ideally, we'd use -library=sunperf, but it's an imperfect world. Studio
2881# cc doesn't recognise -library, it wants -xlic_lib. Studio 12 CC doesn't
2882# recognise -xlic_lib. Libtool doesn't like -xlic_lib anyway. Sun claims
2883# that CC and cc will understand -library in Studio 13. The main extra
2884# function of -xlic_lib and -library is to arrange for the Fortran run-time
2885# libraries to be linked for C++ and C. We can arrange that explicitly.
2886    *-*-solaris*)
2887      SAVE_LIBS="$LIBS"
2888      AC_MSG_CHECKING([for BLAS in libsunperf])
2889      LIBS="-lsunperf $FLIBS $LIBS"
2890      AC_COIN_TRY_FLINK([daxpy],
2891                        [AC_MSG_RESULT([yes])
2892                         use_blas='-lsunperf'
2893                         ADDLIBS="-lsunperf $ADDLIBS"
2894                         coin_need_flibs=yes],
2895                        [AC_MSG_RESULT([no])
2896                         LIBS="$SAVE_LIBS"])
2897      ;;
2898    *-cygwin* | *-mingw*)
2899# On cygwin, consider -lblas only if doscompile is disabled. The prebuilt
2900# library will want to link with cygwin, hence won't run standalone in DOS.
2901      if test "$enable_doscompile" = mingw; then
2902        skip_lblas_check=yes
2903      fi
2904      case "$CC" in
2905        cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
2906          SAVE_LIBS="$LIBS"
2907          AC_MSG_CHECKING([for BLAS in MKL])
2908          LIBS="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib $LIBS"
2909          AC_COIN_TRY_FLINK([daxpy],
2910                            [AC_MSG_RESULT([yes])
2911                             use_blas='mkl_intel_c.lib mkl_sequential.lib mkl_core.lib'
2912                             ADDLIBS="mkl_intel_c.lib mkl_sequential.lib mkl_core.lib $ADDLIBS"],
2913                            [AC_MSG_RESULT([no])
2914                             LIBS="$SAVE_LIBS"])
2915          ;;
2916      esac
2917      ;;
2918  esac
2919
2920  if test -z "$use_blas" && test $skip_lblas_check = no; then
2921    SAVE_LIBS="$LIBS"
2922    AC_MSG_CHECKING([whether -lblas has BLAS])
2923    LIBS="-lblas $LIBS"
2924    AC_COIN_TRY_FLINK([daxpy],
2925                      [AC_MSG_RESULT([yes])
2926                       ADDLIBS="-lblas $ADDLIBS"
2927                       use_blas='-lblas'],
2928                      [AC_MSG_RESULT([no])
2929                       LIBS="$SAVE_LIBS"])
2930  fi
2931
2932# If we have no other ideas, consider building BLAS.
2933  if test -z "$use_blas"; then
2934    if test "$PACKAGE_NAME" != ThirdPartyBlas; then
2935      if test -r $coin_blasobjdir/.MakeOk; then
2936        use_blas=BUILD
2937      fi
2938    fi
2939  fi
2940fi
2941
2942if test "$use_blas" = BUILD; then
2943  coin_need_flibs=yes
2944fi
2945
2946AM_CONDITIONAL([COIN_HAS_BLAS],[test x"$use_blas" != x])
2947AM_CONDITIONAL([COIN_BUILD_BLAS],[test "$use_blas" = BUILD])
2948
2949if test x"$use_blas" = x || test "$use_blas" = no; then
2950  coin_has_blas=no
2951else
2952  coin_has_blas=yes
2953  AC_DEFINE([COIN_HAS_BLAS],[1],
2954            [If defined, the BLAS Library is available.])
2955fi
2956]) # AC_COIN_HAS_BLAS
2957
2958###########################################################################
2959#                            COIN_HAS_LAPACK                              #
2960###########################################################################
2961
2962# This macro checks for a library containing the LAPACK library.  It
2963# tries standard libraries, and if none is found to be working, it
2964# checks whether the LAPACK ThirdParty/Lapack directory has been
2965# configured.  It adds to ADDLIBS any flags required to link with an
2966# externally provided LAPACK.  It defines the makefile conditional and
2967# preprocessor macro COIN_HAS_LAPACK, if lapack is available, and it
2968# defines the makefile conditional COIN_BUILD_LAPACK, if lapack is
2969# compiled within COIN.
2970
2971AC_DEFUN([AC_COIN_HAS_LAPACK],
2972[coin_lapackobjdir=../ThirdParty/Lapack
2973coin_lapacksrcdir=$srcdir/$coin_lapackobjdir
2974
2975AC_ARG_WITH([lapack],
2976            AC_HELP_STRING([--with-lapack],
2977                           [specify LAPACK library (or BUILD for compilation)]),
2978            [use_lapack=$withval], [use_lapack=])
2979
2980# Check if user supplied option makes sense
2981if test x"$use_lapack" != x; then
2982  if test "$use_lapack" = "BUILD"; then
2983    # Don't check for course code if this is executed in ThirdParty/Lapack
2984    if test "$PACKAGE_NAME" != ThirdPartyLapack; then
2985      if test -r $coin_lapackobjdir/.MakeOk; then :; else
2986        AC_MSG_ERROR([option \"BUILD\" specified for LAPACK, but $coin_lapackobjdir directory is not configured])
2987      fi
2988    fi
2989  elif test "$use_lapack" != no; then
2990    AC_MSG_CHECKING([whether user supplied LAPACKLIB=\"$use_lapack\" works])
2991    LIBS="$use_lapack $LIBS"
2992    ADDLIBS="$use_lapack $ADDLIBS"
2993    AC_COIN_TRY_FLINK([dsyev],
2994                      [AC_MSG_RESULT([yes])],
2995                      [AC_MSG_RESULT([no])
2996                       AC_MSG_ERROR([user supplied LAPACK library \"$use_lapack\" does not work])])
2997  fi
2998else
2999  if test x$coin_has_blas = xyes; then
3000    # First try to see if LAPACK is already available with BLAS library
3001    AC_MSG_CHECKING([whether LAPACK is already available with BLAS library])
3002    AC_COIN_TRY_FLINK([dsyev],
3003                      [AC_MSG_RESULT([yes]); use_lapack=ok],
3004                      [AC_MSG_RESULT([no])])
3005  fi
3006  skip_llapack_check=no
3007  if test -z "$use_lapack"; then
3008    # Try to autodetect the library for lapack based on build system
3009    case $build in
3010      *-sgi-*)
3011        SAVE_LIBS="$LIBS"
3012        AC_MSG_CHECKING([whether -lcomplib.sgimath has LAPACK])
3013        LIBS="-lcomplib.sgimath $LIBS"
3014        AC_COIN_TRY_FLINK([dsyev],
3015                          [AC_MSG_RESULT([yes])
3016                           use_lapack=-lcomplib.sgimath;
3017                           ADDLIBS="-lcomplib.sgimath $ADDLIBS"],
3018                          [AC_MSG_RESULT([no])
3019                           SAVE_LIBS="$LIBS"])
3020        ;;
3021
3022# See comments in COIN_HAS_BLAS.
3023      *-*-solaris*)
3024      SAVE_LIBS="$LIBS"
3025      AC_MSG_CHECKING([for LAPACK in libsunperf])
3026      LIBS="-lsunperf $FLIBS $LIBS"
3027      AC_COIN_TRY_FLINK([dsyev],
3028                        [AC_MSG_RESULT([yes])
3029                         use_blas='-lsunperf'
3030                         ADDLIBS="-lsunperf $ADDLIBS"
3031                         coin_need_flibs=yes],
3032                        [AC_MSG_RESULT([no])
3033                         LIBS="$SAVE_LIBS"])
3034        ;;
3035# On cygwin, do this check only if doscompile is disabled. The prebuilt library
3036# will want to link with cygwin, hence won't run standalone in DOS.
3037      *-cygwin*)
3038        if test "$enable_doscompile" = mingw; then
3039          skip_llapack_check=yes
3040        fi
3041        ;;
3042    esac
3043  fi
3044
3045  if test -z "$use_lapack" && test $skip_llapack_check = no; then
3046    SAVE_LIBS="$LIBS"
3047    AC_MSG_CHECKING([whether -llapack has LAPACK])
3048    LIBS="-llapack $LIBS"
3049    AC_COIN_TRY_FLINK([dsyev],
3050                      [AC_MSG_RESULT([yes])
3051                       ADDLIBS="-llapack $ADDLIBS"
3052                       use_lapack='-llapack'],
3053                      [AC_MSG_RESULT([no])
3054                       LIBS="$SAVE_LIBS"])
3055  fi
3056
3057# If we have no other ideas, consider building LAPACK.
3058  if test -z "$use_lapack"; then
3059    if test "$PACKAGE_NAME" != ThirdPartyLapack; then
3060      if test -r $coin_lapackobjdir/.MakeOk; then
3061        use_lapack=BUILD
3062      fi
3063    fi
3064  fi
3065fi
3066
3067if test "$use_lapack" = BUILD; then
3068  coin_need_flibs=yes
3069fi
3070
3071AM_CONDITIONAL([COIN_HAS_LAPACK],[test x"$use_lapack" != x])
3072AM_CONDITIONAL([COIN_BUILD_LAPACK],[test "$use_lapack" = BUILD])
3073
3074if test x"$use_lapack" = x || test "$use_lapack" = no; then
3075  coin_has_lapack=no
3076else
3077  coin_has_lapack=yes
3078  AC_DEFINE([COIN_HAS_LAPACK],[1],
3079            [If defined, the LAPACK Library is available.])
3080fi
3081]) # AC_COIN_HAS_LAPACK
3082
3083###########################################################################
3084#                            COIN_HAS_MUMPS                               #
3085###########################################################################
3086
3087# This macro checks for a library containing the MUMPS library.  It
3088# checks if the user has provided an argument for the MUMPS library,
3089# and if not, it checks whether the MUMPS ThirdParty/Mumps directory has
3090# been configured.  It adds to ADDLIBS any flags required to link with
3091# an externally provided MUMPS.  It defines the makefile conditional
3092# and preprocessor macro COIN_HAS_MUMPS, if MUMPS is available, and it
3093# defines the makefile conditional COIN_BUILD_MUMPS, if MUMPS is
3094# compiled within COIN.
3095
3096AC_DEFUN([AC_COIN_HAS_MUMPS],
3097[
3098if test "$PACKAGE_NAME" = ThirdPartyMumps; then
3099  coin_mumpsobjdir=../Mumps
3100else
3101  coin_mumpsobjdir=../ThirdParty/Mumps
3102fi
3103coin_mumpssrcdir=$abs_source_dir/$coin_mumpsobjdir/MUMPS
3104
3105MAKEOKFILE=.MakeOk
3106
3107#check if user provides a MUMPS library (that works)
3108AC_LANG_PUSH(C)
3109SAVE_ADDLIBS="$ADDLIBS"
3110ADDLIBS="$ADDLIBS $FLIBS"
3111AC_COIN_HAS_USER_LIBRARY(mumps, MUMPS, dmumps_c.h, dmumps_c)
3112ADDLIBS="$SAVE_ADDLIBS"
3113AC_LANG_POP(C)
3114
3115if test "$coin_has_mumps" = "true"; then  # user provided mumps library
3116  use_mumps=yes
3117  coin_has_mumps=yes
3118
3119  MUMPS_INCFLAGS="-I\`\$(CYGPATH_W) $MUMPSINCDIR\`"
3120  ADDLIBS="$MUMPSLIB $ADDLIBS"
3121
3122else # no user provided library, so we try to build our own
3123  use_mumps=BUILD
3124
3125  # Check if the MUMPS' ThirdParty project has been configured
3126  if test "$PACKAGE_NAME" != ThirdPartyMumps; then
3127    if test -r $coin_mumpsobjdir/.MakeOk; then
3128      use_mumps=BUILD
3129      # Mumps needs pthreads
3130      AC_LANG_PUSH(C)
3131      save_LIBS="$LIBS"
3132      LIBS="$LIBS $FLIBS"
3133      AC_CHECK_LIB([pthread],[pthread_create],[LIBS="-lpthread $save_LIBS"; ADDLIBS="-lpthread $ADDLIBS"],[LIBS="save_LIBS"])
3134      AC_LANG_POP(C)
3135 
3136      MUMPS_INCFLAGS="-I\`\$(CYGPATH_W) $coin_mumpssrcdir/libseq\` -I\`\$(CYGPATH_W) $coin_mumpssrcdir/include\`"
3137    else
3138      use_mumps=
3139    fi
3140  fi
3141
3142  # if a user provided library is used, then COIN_HAS_USER_LIBRARY takes care of the COIN_HAS_MUMPS conditional and preprocessor symbol
3143  AM_CONDITIONAL([COIN_HAS_MUMPS],[test x"$use_mumps" != x])
3144  if test x"$use_mumps" != x; then
3145    AC_DEFINE([COIN_HAS_MUMPS],[1],[If defined, the MUMPS Library is available.])
3146    coin_has_mumps=yes
3147  else
3148    coin_has_mumps=no
3149  fi
3150  AC_MSG_CHECKING([whether MUMPS is available])
3151  AC_MSG_RESULT([$coin_has_mumps])
3152fi
3153
3154if test x"$use_mumps" != x; then
3155  # we need the Fortran runtime libraries if we want to link with C/C++
3156  coin_need_flibs=yes
3157
3158  AC_SUBST(MUMPS_INCFLAGS)
3159fi
3160
3161AM_CONDITIONAL([COIN_BUILD_MUMPS],[test "$use_mumps" = BUILD])
3162
3163]) # AC_COIN_HAS_MUMPS
3164
3165###########################################################################
3166#                            COIN_HAS_METIS                               #
3167###########################################################################
3168
3169# This macro checks for a library containing the METIS library.  It
3170# checks if the user has provided an argument for the METIS library,
3171# and if not, it checks whether the METIS ThirdParty/Metis directory has
3172# been configured.  It adds to ADDLIBS any flags required to link with
3173# an externally provided METIS.  It defines the makefile conditional
3174# and preprocessor macro COIN_HAS_METIS, if METIS is available, and it
3175# defines the makefile conditional COIN_BUILD_METIS, if METIS is
3176# compiled within COIN.
3177
3178AC_DEFUN([AC_COIN_HAS_METIS],
3179[
3180case "$PACKAGE_NAME" in
3181  ThirdParty*)
3182    coin_metisobjdir=../Metis
3183    ;;
3184  *)
3185    coin_metisobjdir=../ThirdParty/Metis
3186    ;;
3187esac
3188
3189MAKEOKFILE=.MakeOk
3190
3191#check if user provides a METIS library (that works)
3192AC_LANG_PUSH(C)
3193AC_ARG_WITH(metis,
3194   AS_HELP_STRING([--with-metis], [specify flags to link with METIS library]),
3195   [METISLIB="$withval"; coin_has_metis=true], [coin_has_metis=no])
3196
3197if test $coin_has_metis = true; then
3198  coin_save_LIBS="$LIBS"
3199  LIBS="$METISLIB $ADDLIBS"
3200  AC_MSG_CHECKING([whether symbol metis_nodend is available with ])
3201  AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[metis_nodend()]])],
3202     [AC_MSG_RESULT(yes)],
3203     [AC_MSG_RESULT(no)
3204      AC_MSG_ERROR([User-supplied METIS library does not work])])
3205  LIBS="$coin_save_LIBS"
3206fi
3207AC_LANG_POP(C)
3208
3209if test "$coin_has_metis" = "true"; then  # user provided metis library
3210  use_metis=yes
3211  coin_has_metis=yes
3212
3213  ADDLIBS="$METISLIB $ADDLIBS"
3214
3215else # no user provided library, so we try to build our own
3216  use_metis=BUILD
3217
3218  # Check if the METIS' ThirdParty project has been configured
3219  if test "$PACKAGE_NAME" != ThirdPartyMetis; then
3220    if test -r $coin_metisobjdir/.MakeOk; then
3221      use_metis=BUILD
3222    else
3223      use_metis=
3224    fi
3225  fi
3226
3227  if test x"$use_metis" != x; then
3228    coin_has_metis=yes
3229  else
3230    coin_has_metis=no
3231  fi
3232  AC_MSG_CHECKING([whether METIS is available])
3233  AC_MSG_RESULT([$coin_has_metis])
3234fi
3235
3236AM_CONDITIONAL([COIN_HAS_METIS],[test $coin_has_metis = yes])
3237if test $coin_has_metis = yes; then
3238  AC_DEFINE([COIN_HAS_METIS],[1],[If defined, the METIS library is available.])
3239fi
3240
3241]) # AC_COIN_HAS_METIS
3242
3243
3244###########################################################################
3245#                             COIN_HAS_GLPK                               #
3246###########################################################################
3247#
3248# This macro checks for the GLPK package. GLPK provides two capabilities,
3249# an LP and MIP solver (GLPK) and the GNU Mathprog modelling language (GMPL).
3250# The macro checks for either Glpk or Gmpl, according to the value specified as
3251# the parameter. Use one of Glpk or Gmpl. Use *exactly* these strings, eh?
3252#
3253#
3254# The macro first uses COIN_HAS_USER_LIBRARY to see if the user has specified
3255# a preexisting library (this allows the use of any glpk version, if the user
3256# is fussy). The macro then checks for ThirdParty/Glpk.
3257#
3258# This macro will define the following variables for Glpk:
3259#   coin_has_glpk       true or false
3260#   GLPKLIB             link flags for GLPK (if user supplied)
3261#   GLPKINCDIR          location of glpk include files
3262#   COIN_HAS_GLPK       Preprocessor symbol, defined to 1
3263#   COIN_HAS_GLPK       Automake conditional
3264#   COIN_BUILD_GLPK     Automake conditional, defined only if Glpk is to be
3265#                       built in ThirdParty/Glpk
3266#
3267# With the exception of COIN_BUILD_GLPK, an identical set of variables is
3268# defined for Gmpl.
3269
3270AC_DEFUN([AC_COIN_HAS_GLPK],
3271[
3272if test "$PACKAGE_NAME" = ThirdPartyGlpk; then
3273  coin_glpkobjdir=../Glpk
3274else
3275  coin_glpkobjdir=../ThirdParty/Glpk
3276fi
3277coin_glpksrcdir=$abs_source_dir/$coin_glpkobjdir
3278
3279use_thirdpartyglpk=no
3280
3281# Check for the requested component. If the user specified an external glpk
3282# library don't force a ThirdParty build, let the error propagate.
3283
3284m4_if([$1],[Glpk],
3285[AC_COIN_HAS_USER_LIBRARY([Glpk],[GLPK],[glpk.h],
3286    [_glp_lpx_simplex glp_lpx_simplex])
3287 if test x"$coin_has_glpk" = xfalse && test x"$GLPKLIB" = x ; then
3288   use_thirdpartyglpk=try
3289 fi])
3290m4_if([$1],[Gmpl],
3291[AC_COIN_HAS_USER_LIBRARY([Gmpl],[GMPL],[glpmpl.h],
3292    [_glp_mpl_initialize glp_mpl_initialize])
3293 if test x"$coin_has_gmpl" = xfalse && test x"$GMPLLIB" = x ; then
3294   use_thirdpartyglpk=try
3295 fi])
3296
3297# If the user has supplied an external library, use it. Otherwise, consider
3298# a build in ThirdParty/Glpk. If we build, assume we get both glpk and gmpl.
3299
3300if test x"$use_thirdpartyglpk" = xtry ; then
3301  MAKEOKFILE=.MakeOk
3302  # Check if the Glpk's ThirdParty project has been configured
3303  if test "$PACKAGE_NAME" != ThirdPartyGlpk; then
3304    if test -r $coin_glpkobjdir/.MakeOk; then
3305      use_thirdpartyglpk=build
3306    else
3307      use_thirdpartyglpk=no
3308    fi
3309  else
3310    use_thirdpartyglpk=build
3311  fi
3312
3313# If we're building, set the library and include directory variables, create a
3314# preprocessor symbol, define a variable that says we're using glpk/gmpl, and
3315# another to indicate a link check is a bad idea (hard to do before the library
3316# exists).
3317
3318  if test x"$use_thirdpartyglpk" = xbuild ; then
3319    m4_toupper($1INCDIR)="$coin_glpksrcdir/glpk/include"
3320    AC_SUBST(m4_toupper($1INCDIR))
3321    AC_DEFINE(m4_toupper(COIN_HAS_$1),[1],
3322              [Define to 1 if $1 package is available])
3323    m4_tolower(coin_has_$1)=true
3324    m4_tolower($1_libcheck)=no
3325    m4_toupper($1OBJDIR)=`cd $coin_glpkobjdir; pwd`
3326    AC_SUBST(m4_toupper($1OBJDIR))
3327    AC_MSG_NOTICE([Using $1 in ThirdParty/Glpk])
3328  fi
3329fi
3330
3331# Define the necessary automake conditionals.
3332
3333AM_CONDITIONAL(m4_toupper(COIN_HAS_$1),
3334               [test x"$m4_tolower(coin_has_$1)" = xtrue])
3335AM_CONDITIONAL([COIN_BUILD_GLPK],[test x"$use_thirdpartyglpk" = xbuild])
3336
3337]) # AC_COIN_HAS_GLPK
Note: See TracBrowser for help on using the repository browser.