| blob | b360c39249cc918b4f4027d0250d9cd178fe434d |
1 # This file is part of Autoconf. -*- Autoconf -*-
2 # Programming languages support.
3 # Copyright 2000, 2001
4 # Free Software Foundation, Inc.
5 #
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2, or (at your option)
9 # any later version.
10 #
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 # 02111-1307, USA.
20 #
21 # As a special exception, the Free Software Foundation gives unlimited
22 # permission to copy, distribute and modify the configure scripts that
23 # are the output of Autoconf. You need not follow the terms of the GNU
24 # General Public License when using or distributing such scripts, even
25 # though portions of the text of Autoconf appear in them. The GNU
26 # General Public License (GPL) does govern all other use of the material
27 # that constitutes the Autoconf program.
28 #
29 # Certain portions of the Autoconf source text are designed to be copied
30 # (in certain cases, depending on the input) into the output of
31 # Autoconf. We call these the "data" portions. The rest of the Autoconf
32 # source text consists of comments plus executable code that decides which
33 # of the data portions to output in any given case. We call these
34 # comments and executable code the "non-data" portions. Autoconf never
35 # copies any of the non-data portions into its output.
36 #
37 # This special exception to the GPL applies to versions of Autoconf
38 # released by the Free Software Foundation. When you make and
39 # distribute a modified version of Autoconf, you may extend this special
40 # exception to the GPL to apply to your modified version as well, *unless*
41 # your modified version has the potential to copy into its output some
42 # of the text that was the non-data portion of the version that you started
43 # with. (In other words, unless your change moves or copies text from
44 # the non-data portions to the data portions.) If your modification has
45 # such potential, you must delete any notice of this special exception
46 # to the GPL from your modified version.
47 #
48 # Written by David MacKenzie, with help from
49 # Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
50 # Roland McGrath, Noah Friedman, david d zuhn, and many others.
53 # Table of Contents:
54 #
55 # 1. Language selection
56 # and routines to produce programs in a given language.
57 # a. generic routines
58 # b. C
59 # c. C++
60 # d. Fortran 77
61 #
62 # 2. Producing programs in a given language.
63 # a. generic routines
64 # b. C
65 # c. C++
66 # d. Fortran 77
67 #
68 # 3. Looking for a compiler
69 # And possibly the associated preprocessor.
70 # a. Generic routines.
71 # b. C
72 # c. C++
73 # d. Fortran 77
74 #
75 # 4. Compilers' characteristics.
76 # a. Generic routines.
77 # b. C
78 # c. C++
79 # d. Fortran 77
83 ## ----------------------- ##
84 ## 1. Language selection. ##
85 ## ----------------------- ##
89 # -------------------------------- #
90 # 1a. Generic language selection. #
91 # -------------------------------- #
93 # AC_LANG_CASE(LANG1, IF-LANG1, LANG2, IF-LANG2, ..., DEFAULT)
94 # ------------------------------------------------------------
95 # Expand into IF-LANG1 if the current language is LANG1 etc. else
96 # into default.
97 m4_define([AC_LANG_CASE],
98 [m4_case(_AC_LANG, $@)])
101 # _AC_LANG_DISPATCH(MACRO, LANG, ARGS)
102 # ------------------------------------
103 # Call the specialization of MACRO for LANG with ARGS. Complain if
104 # unavailable.
105 m4_define([_AC_LANG_DISPATCH],
106 [m4_ifdef([$1($2)],
107 [m4_indir([$1($2)], m4_shiftn(2, $@))],
108 [AC_FATAL([$1: unknown language: $2])])])
111 # _AC_LANG_SET(OLD, NEW)
112 # ----------------------
113 # Output the shell code needed to switch from OLD language to NEW language.
114 # Do not try to optimize like this:
115 #
116 # m4_defun([_AC_LANG_SET],
117 # [m4_if([$1], [$2], [],
118 # [_AC_LANG_DISPATCH([AC_LANG], [$2])])])
119 #
120 # as it can introduce differences between the sh-current language and the
121 # m4-current-language when m4_require is used. Something more subtle
122 # might be possible, but at least for the time being, play it safe.
123 m4_defun([_AC_LANG_SET],
124 [_AC_LANG_DISPATCH([AC_LANG], [$2])])
127 # AC_LANG(LANG)
128 # -------------
129 # Set the current language to LANG.
130 m4_defun([AC_LANG],
131 [_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]),
132 [$1])dnl
133 m4_define([_AC_LANG], [$1])])
136 # AC_LANG_PUSH(LANG)
137 # ------------------
138 # Save the current language, and use LANG.
139 m4_defun([AC_LANG_PUSH],
140 [_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]),
141 [$1])dnl
142 m4_pushdef([_AC_LANG], [$1])])
145 # AC_LANG_POP([LANG])
146 # -------------------
147 # If given, check that the current language is LANG, and restore the
148 # previous language.
149 m4_defun([AC_LANG_POP],
150 [m4_ifval([$1],
151 [m4_if([$1], m4_defn([_AC_LANG]), [],
152 [m4_fatal([$0($1): unexpected current language: ]m4_defn([_AC_LANG]))])])dnl
153 m4_pushdef([$0 OLD], m4_defn([_AC_LANG]))dnl
154 m4_popdef([_AC_LANG])dnl
155 _AC_LANG_SET(m4_defn([$0 OLD]), m4_defn([_AC_LANG]))dnl
156 m4_popdef([$0 OLD])dnl
157 ])
160 # AC_LANG_SAVE
161 # ------------
162 # Save the current language, but don't change language.
163 AU_DEFUN([AC_LANG_SAVE],
164 [AC_DIAGNOSE([obsolete],
165 [instead of using `AC_LANG', `AC_LANG_SAVE',
166 and `AC_LANG_RESTORE', you should use `AC_LANG_PUSH' and `AC_LANG_POP'.])
167 m4_pushdef([_AC_LANG], _AC_LANG)])
170 # AC_LANG_RESTORE
171 # ---------------
172 # Restore the current language from the stack.
173 AU_DEFUN([AC_LANG_RESTORE], [AC_LANG_POP($@)])
176 # _AC_LANG_ABBREV
177 # ---------------
178 # Return a short signature of _AC_LANG which can be used in shell
179 # variable names, or in M4 macro names.
180 m4_defun([_AC_LANG_ABBREV],
181 [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
184 # AC_LANG_ASSERT(LANG)
185 # --------------------
186 # Current language must be LANG.
187 m4_defun([AC_LANG_ASSERT],
188 [m4_if(_AC_LANG, $1, [],
189 [m4_fatal([$0: current language is not $1: ] _AC_LANG)])])
193 # -------------------- #
194 # 1b. The C language. #
195 # -------------------- #
198 # AC_LANG(C)
199 # ----------
200 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
201 m4_define([AC_LANG(C)],
202 [ac_ext=c
203 ac_cpp='$CPP $CPPFLAGS'
204 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
205 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
206 ac_compiler_gnu=$ac_cv_c_compiler_gnu
207 ])
210 # AC_LANG_C
211 # ---------
212 AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
215 # _AC_LANG_ABBREV(C)
216 # ------------------
217 m4_define([_AC_LANG_ABBREV(C)], [c])
220 # ---------------------- #
221 # 1c. The C++ language. #
222 # ---------------------- #
225 # AC_LANG(C++)
226 # ------------
227 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
228 m4_define([AC_LANG(C++)],
229 [ac_ext=cc
230 ac_cpp='$CXXCPP $CPPFLAGS'
231 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
232 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
233 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
234 ])
237 # AC_LANG_CPLUSPLUS
238 # -----------------
239 AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)])
242 # _AC_LANG_ABBREV(C++)
243 # --------------------
244 m4_define([_AC_LANG_ABBREV(C++)], [cxx])
247 # ----------------------------- #
248 # 1d. The Fortran 77 language. #
249 # ----------------------------- #
252 # AC_LANG(Fortran 77)
253 # -------------------
254 m4_define([AC_LANG(Fortran 77)],
255 [ac_ext=f
256 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
257 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
258 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
259 ])
262 # AC_LANG_FORTRAN77
263 # -----------------
264 AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)])
267 # _AC_LANG_ABBREV(Fortran 77)
268 # ---------------------------
269 m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77])
273 ## ---------------------- ##
274 ## 2.Producing programs. ##
275 ## ---------------------- ##
278 # ---------------------- #
279 # 2a. Generic routines. #
280 # ---------------------- #
283 # AC_LANG_CONFTEST(BODY)
284 # ----------------------
285 # Save the BODY in `conftest.$ac_ext'. Add a trailing new line.
286 m4_define([AC_LANG_CONFTEST],
287 [cat >conftest.$ac_ext <<_ACEOF
288 $1
289 _ACEOF])
292 # AC_LANG_SOURCE(BODY)
293 # --------------------
294 # Produce a valid source for the current language, which includes the
295 # BODY, and as much as possible `confdefs.h' and the `#line' sync
296 # lines.
297 AC_DEFUN([AC_LANG_SOURCE],
298 [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
301 # AC_LANG_PROGRAM([PROLOGUE], [BODY])
302 # -----------------------------------
303 # Produce a valid source for the current language. Prepend the
304 # PROLOGUE (typically CPP directives and/or declarations) to an
305 # execution the BODY (typically glued inside the `main' function, or
306 # equivalent).
307 AC_DEFUN([AC_LANG_PROGRAM],
308 [AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])])
311 # AC_LANG_CALL(PROLOGUE, FUNCTION)
312 # --------------------------------
313 # Call the FUNCTION.
314 AC_DEFUN([AC_LANG_CALL],
315 [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
318 # AC_LANG_FUNC_LINK_TRY(FUNCTION)
319 # -------------------------------
320 # Produce a source which links correctly iff the FUNCTION exists.
321 AC_DEFUN([AC_LANG_FUNC_LINK_TRY],
322 [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
325 # AC_LANG_BOOL_COMPILE_TRY(PROLOGUE, EXPRESSION)
326 # ----------------------------------------------
327 # Produce a program that compiles with success iff the boolean EXPRESSION
328 # evaluates to true at compile time.
329 AC_DEFUN([AC_LANG_BOOL_COMPILE_TRY],
330 [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
333 # AC_LANG_INT_SAVE(PROLOGUE, EXPRESSION)
334 # --------------------------------------
335 # Produce a program that saves the runtime evaluation of the integer
336 # EXPRESSION into `conftest.val'.
337 AC_DEFUN([AC_LANG_INT_SAVE],
338 [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
341 # --------------- #
342 # 2b. C sources. #
343 # --------------- #
345 # AC_LANG_SOURCE(C)(BODY)
346 # -----------------------
347 # This sometimes fails to find confdefs.h, for some reason.
348 # #line __oline__ "$[0]"
349 m4_define([AC_LANG_SOURCE(C)],
350 [#line __oline__ "configure"
351 #include "confdefs.h"
352 $1])
355 # AC_LANG_PROGRAM(C)([PROLOGUE], [BODY])
356 # --------------------------------------
357 # If AC_F77_DUMMY_MAIN was run, then any C/C++ program might be linked
358 # against Fortran code, hence a dummy main might be needed.
359 m4_define([AC_LANG_PROGRAM(C)],
360 [$1
361 m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS()])dnl
362 int
363 main ()
364 {
365 dnl Do *not* indent the following line: there may be CPP directives.
366 dnl Don't move the `;' right after for the same reason.
367 $2
368 ;
369 return 0;
370 }])
373 # AC_LANG_CALL(C)(PROLOGUE, FUNCTION)
374 # -----------------------------------
375 # Avoid conflicting decl of main.
376 m4_define([AC_LANG_CALL(C)],
377 [AC_LANG_PROGRAM([$1
378 m4_if([$2], [main], ,
379 [/* Override any gcc2 internal prototype to avoid an error. */
380 #ifdef __cplusplus
381 extern "C"
382 #endif
383 /* We use char because int might match the return type of a gcc2
384 builtin and then its argument prototype would still apply. */
385 char $2 ();])], [$2 ();])])
388 # AC_LANG_FUNC_LINK_TRY(C)(FUNCTION)
389 # ----------------------------------
390 # Don't include <ctype.h> because on OSF/1 3.0 it includes
391 # <sys/types.h> which includes <sys/select.h> which contains a
392 # prototype for select. Similarly for bzero.
393 m4_define([AC_LANG_FUNC_LINK_TRY(C)],
394 [AC_LANG_PROGRAM(
395 [/* System header to define __stub macros and hopefully few prototypes,
396 which can conflict with char $1 (); below. */
397 #include <assert.h>
398 /* Override any gcc2 internal prototype to avoid an error. */
399 #ifdef __cplusplus
400 extern "C"
401 #endif
402 /* We use char because int might match the return type of a gcc2
403 builtin and then its argument prototype would still apply. */
404 char $1 ();
405 char (*f) ();
406 ],
407 [/* The GNU C library defines this for functions which it implements
408 to always fail with ENOSYS. Some functions are actually named
409 something starting with __ and the normal name is an alias. */
410 #if defined (__stub_$1) || defined (__stub___$1)
411 choke me
412 #else
413 f = $1;
414 #endif
415 ])])
418 # AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION)
419 # -------------------------------------------------
420 m4_define([AC_LANG_BOOL_COMPILE_TRY(C)],
421 [AC_LANG_PROGRAM([$1], [int _array_ @<:@1 - 2 * !($2)@:>@])])
424 # AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION)
425 # -----------------------------------------
426 # We need `stdio.h' to open a `FILE', so the prologue defaults to the
427 # inclusion of `stdio.h'.
428 m4_define([AC_LANG_INT_SAVE(C)],
429 [AC_LANG_PROGRAM([m4_default([$1], [@%:@include <stdio.h>])],
430 [FILE *f = fopen ("conftest.val", "w");
431 if (!f)
432 exit (1);
433 fprintf (f, "%d", ($2));
434 fclose (f);])])
437 # ----------------- #
438 # 2c. C++ sources. #
439 # ----------------- #
441 # AC_LANG_SOURCE(C++)(BODY)
442 # -------------------------
443 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)])
446 # AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
447 # ----------------------------------------
448 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)])
451 # AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
452 # -------------------------------------
453 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)])
456 # AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
457 # ------------------------------------
458 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)])
461 # AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION)
462 # ---------------------------------------------------
463 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)])
466 # AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
467 # -------------------------------------------
468 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)])
472 # ------------------------ #
473 # 2d. Fortran 77 sources. #
474 # ------------------------ #
476 # AC_LANG_SOURCE(Fortran 77)(BODY)
477 # --------------------------------
478 # FIXME: Apparently, according to former AC_TRY_COMPILER, the CPP
479 # directives must not be included. But AC_TRY_RUN_NATIVE was not
480 # avoiding them, so?
481 m4_define([AC_LANG_SOURCE(Fortran 77)],
482 [$1])
485 # AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY])
486 # -----------------------------------------------
487 # Yes, we discard the PROLOGUE.
488 m4_define([AC_LANG_PROGRAM(Fortran 77)],
489 [m4_ifval([$1],
490 [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl
491 program main
492 $2
493 end])
496 # AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION)
497 # --------------------------------------------
498 # FIXME: This is a guess, help!
499 m4_define([AC_LANG_CALL(Fortran 77)],
500 [AC_LANG_PROGRAM([$1],
501 [ call $2])])
506 ## -------------------------------------------- ##
507 ## 3. Looking for Compilers and Preprocessors. ##
508 ## -------------------------------------------- ##
510 # ----------------------------------------------------- #
511 # 3a. Generic routines in compilers and preprocessors. #
512 # ----------------------------------------------------- #
514 # AC_LANG_COMPILER
515 # ----------------
516 # Find a compiler for the current LANG. Be sure to be run before
517 # AC_LANG_PREPROC.
518 #
519 # Note that because we might AC_REQUIRE `AC_LANG_COMPILER(C)' for
520 # instance, the latter must be AC_DEFUN'd, not just define'd.
521 m4_define([AC_LANG_COMPILER],
522 [AC_BEFORE([AC_LANG_COMPILER(]_AC_LANG[)],
523 [AC_LANG_PREPROC(]_AC_LANG[)])dnl
524 _AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
527 # AC_LANG_COMPILER_REQUIRE
528 # ------------------------
529 # Ensure we have a compiler for the current LANG.
530 AC_DEFUN([AC_LANG_COMPILER_REQUIRE],
531 [m4_require([AC_LANG_COMPILER(]_AC_LANG[)],
532 [AC_LANG_COMPILER])])
536 # _AC_LANG_COMPILER_GNU
537 # ---------------------
538 # Check whether the compiler for the current language is GNU.
539 #
540 # It doesn't seem necessary right now to have a different source
541 # according to the current language, since this works fine. Some day
542 # it might be needed. Nevertheless, pay attention to the fact that
543 # the position of `choke me' on the seventh column is meant: otherwise
544 # some Fortran compilers (e.g., SGI) might consider it's a
545 # continuation line, and warn instead of reporting an error.
546 m4_define([_AC_LANG_COMPILER_GNU],
547 [AC_CACHE_CHECK([whether we are using the GNU _AC_LANG compiler],
548 [ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu],
549 [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[#ifndef __GNUC__
550 choke me
551 #endif
552 ]])],
553 [ac_compiler_gnu=yes],
554 [ac_compiler_gnu=no])
555 ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu=$ac_compiler_gnu
556 ])])# _AC_LANG_COMPILER_GNU
559 # AC_LANG_PREPROC
560 # ---------------
561 # Find a preprocessor for the current language. Note that because we
562 # might AC_REQUIRE `AC_LANG_PREPROC(C)' for instance, the latter must
563 # be AC_DEFUN'd, not just define'd. Since the preprocessor depends
564 # upon the compiler, look for the compiler.
565 m4_define([AC_LANG_PREPROC],
566 [AC_LANG_COMPILER_REQUIRE()dnl
567 _AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
570 # AC_LANG_PREPROC_REQUIRE
571 # -----------------------
572 # Ensure we have a preprocessor for the current language.
573 AC_DEFUN([AC_LANG_PREPROC_REQUIRE],
574 [m4_require([AC_LANG_PREPROC(]_AC_LANG[)],
575 [AC_LANG_PREPROC])])
578 # AC_REQUIRE_CPP
579 # --------------
580 # Require the preprocessor for the current language.
581 # FIXME: AU_ALIAS once AC_LANG is officially documented (2.51?).
582 AC_DEFUN([AC_REQUIRE_CPP],
583 [AC_LANG_PREPROC_REQUIRE])
587 # AC_NO_EXECUTABLES
588 # -----------------
589 # FIXME: The GCC team has specific needs which the current Autoconf
590 # framework cannot solve elegantly. This macro implements a dirty
591 # hack until Autoconf is abble to provide the services its users
592 # needs.
593 #
594 # Several of the support libraries that are often built with GCC can't
595 # assume the tool-chain is already capable of linking a program: the
596 # compiler often expects to be able to link with some of such
597 # libraries.
598 #
599 # In several of these libraries, work-arounds have been introduced to
600 # avoid the AC_PROG_CC_WORKS test, that would just abort their
601 # configuration. The introduction of AC_EXEEXT, enabled either by
602 # libtool or by CVS autoconf, have just made matters worse.
603 AC_DEFUN_ONCE([AC_NO_EXECUTABLES],
604 [m4_divert_push([KILL])
606 AC_BEFORE([$0], [_AC_COMPILER_EXEEXT_WORKS])
607 AC_BEFORE([$0], [_AC_COMPILER_EXEEXT])
609 m4_define([_AC_COMPILER_EXEEXT_WORKS],
610 [cross_compiling=maybe
611 ])
613 m4_define([_AC_COMPILER_EXEEXT],
614 [EXEEXT=
615 ])
617 m4_define([AC_LINK_IFELSE],
618 [AC_FATAL([All the tests involving linking were disabled by $0])])
620 m4_divert_pop()dnl
621 ])# AC_NO_EXECUTABLES
625 # ----------------------------- #
626 # Computing EXEEXT and OBJEXT. #
627 # ----------------------------- #
630 # Files to ignore
631 # ---------------
632 # Ignore .d files produced by CFLAGS=-MD.
633 #
634 # On UWIN (which uses a cc wrapper for MSVC), the compiler also generates
635 # a .pdb file
636 #
637 # When the w32 free Borland C++ command line compiler links a program
638 # (conftest.exe), it also produces a file named `conftest.tds' in
639 # addition to `conftest.obj'
642 # We must not AU define them, because autoupdate would then remove
643 # them, which is right, but Automake 1.4 would remove the support for
644 # $(EXEEXT) etc.
645 # FIXME: Remove this once Automake fixed.
646 AC_DEFUN([AC_EXEEXT], [])
647 AC_DEFUN([AC_OBJEXT], [])
650 # _AC_COMPILER_EXEEXT_DEFAULT
651 # ---------------------------
652 # Check for the extension used for the default name for executables.
653 # Beware of `expr' that may return `0' or `'. Since this macro is
654 # the first one in touch with the compiler, it should also check that
655 # it compiles properly.
656 m4_define([_AC_COMPILER_EXEEXT_DEFAULT],
657 [# Try to create an executable without -o first, disregard a.out.
658 # It will help us diagnose broken compilers, and finding out an intuition
659 # of exeext.
660 AC_MSG_CHECKING([for _AC_LANG compiler default output])
661 ac_link_default=`echo "$ac_link" | sed ['s/ -o *conftest[^ ]*//']`
662 AS_IF([AC_TRY_EVAL(ac_link_default)],
663 [# Find the output, starting from the most likely. This scheme is
664 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
665 # resort.
666 for ac_file in `ls a.exe conftest.exe 2>/dev/null;
667 ls a.out conftest 2>/dev/null;
668 ls a.* conftest.* 2>/dev/null`; do
669 case $ac_file in
670 *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;;
671 a.out ) # We found the default executable, but exeext='' is most
672 # certainly right.
673 break;;
674 *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']`
675 # FIXME: I believe we export ac_cv_exeext for Libtool --akim.
676 export ac_cv_exeext
677 break;;
678 * ) break;;
679 esac
680 done],
681 [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD
682 cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD
683 AC_MSG_ERROR([_AC_LANG compiler cannot create executables], 77)])
684 ac_exeext=$ac_cv_exeext
685 AC_MSG_RESULT([$ac_file])
686 ])# _AC_COMPILER_EXEEXT_DEFAULT
689 # _AC_COMPILER_EXEEXT_WORKS
690 # -------------------------
691 m4_define([_AC_COMPILER_EXEEXT_WORKS],
692 [# Check the compiler produces executables we can run. If not, either
693 # the compiler is broken, or we cross compile.
694 AC_MSG_CHECKING([whether the _AC_LANG compiler works])
695 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
696 # If not cross compiling, check that we can run a simple program.
697 if test "$cross_compiling" != yes; then
698 if AC_TRY_COMMAND([./$ac_file]); then
699 cross_compiling=no
700 else
701 if test "$cross_compiling" = maybe; then
702 cross_compiling=yes
703 else
704 AC_MSG_ERROR([cannot run _AC_LANG compiled programs.
705 If you meant to cross compile, use `--host'.])
706 fi
707 fi
708 fi
709 AC_MSG_RESULT([yes])
710 ])# _AC_COMPILER_EXEEXT_WORKS
713 # _AC_COMPILER_EXEEXT_CROSS
714 # -------------------------
715 m4_define([_AC_COMPILER_EXEEXT_CROSS],
716 [# Check the compiler produces executables we can run. If not, either
717 # the compiler is broken, or we cross compile.
718 AC_MSG_CHECKING([whether we are cross compiling])
719 AC_MSG_RESULT([$cross_compiling])
720 ])# _AC_COMPILER_EXEEXT_CROSS
723 # _AC_COMPILER_EXEEXT_O
724 # ---------------------
725 # Check for the extension used when `-o foo'. Try to see if ac_cv_exeext,
726 # as computed by _AC_COMPILER_EXEEXT_DEFAULT is OK.
727 m4_define([_AC_COMPILER_EXEEXT_O],
728 [AC_MSG_CHECKING([for executable suffix])
729 AS_IF([AC_TRY_EVAL(ac_link)],
730 [# If both `conftest.exe' and `conftest' are `present' (well, observable)
731 # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
732 # work properly (i.e., refer to `conftest.exe'), while it won't with
733 # `rm'.
734 for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do
735 case $ac_file in
736 *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;;
737 *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']`
738 export ac_cv_exeext
739 break;;
740 * ) break;;
741 esac
742 done],
743 [AC_MSG_ERROR([cannot compute EXEEXT: cannot compile and link])])
744 rm -f conftest$ac_cv_exeext
745 AC_MSG_RESULT([$ac_cv_exeext])
746 ])# _AC_COMPILER_EXEEXT_O
749 # _AC_COMPILER_EXEEXT
750 # -------------------
751 # Check for the extension used for executables. It compiles a test
752 # executable. If this is called, the executable extensions will be
753 # automatically used by link commands run by the configure script.
754 #
755 # Note that some compilers (cross or not), strictly obey to `-o foo' while
756 # the host requires `foo.exe', so we should not depend upon `-o' to
757 # test EXEEXT. But then, be sure no to destroy user files.
758 #
759 # Must be run before _AC_COMPILER_OBJEXT because _AC_COMPILER_EXEEXT_DEFAULT
760 # checks whether the compiler works.
761 m4_define([_AC_COMPILER_EXEEXT],
762 [AC_LANG_CONFTEST([AC_LANG_PROGRAM()])
763 ac_clean_files_save=$ac_clean_files
764 ac_clean_files="$ac_clean_files a.out a.exe"
765 _AC_COMPILER_EXEEXT_DEFAULT
766 _AC_COMPILER_EXEEXT_WORKS
767 rm -f a.out a.exe conftest$ac_cv_exeext
768 ac_clean_files=$ac_clean_files_save
769 _AC_COMPILER_EXEEXT_CROSS
770 _AC_COMPILER_EXEEXT_O
771 rm -f conftest.$ac_ext
772 AC_SUBST([EXEEXT], [$ac_cv_exeext])dnl
773 ac_exeext=$EXEEXT
774 ])# _AC_COMPILER_EXEEXT
777 # _AC_COMPILER_OBJEXT
778 # -------------------
779 # Check the object extension used by the compiler: typically `.o' or
780 # `.obj'. If this is called, some other behaviour will change,
781 # determined by ac_objext.
782 #
783 # This macro is called by AC_LANG_COMPILER, the latter being required
784 # by the AC_COMPILE_IFELSE macros, so use _AC_COMPILE_IFELSE. And in fact,
785 # don't, since _AC_COMPILE_IFELSE needs to know ac_objext for the `test -s'
786 # it includes. So do it by hand.
787 m4_define([_AC_COMPILER_OBJEXT],
788 [AC_CACHE_CHECK([for object suffix], ac_cv_objext,
789 [AC_LANG_CONFTEST([AC_LANG_PROGRAM()])
790 rm -f conftest.o conftest.obj
791 AS_IF([AC_TRY_EVAL(ac_compile)],
792 [for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
793 case $ac_file in
794 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb ) ;;
795 *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
796 break;;
797 esac
798 done],
799 [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD
800 cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD
801 AC_MSG_ERROR([cannot compute OBJEXT: cannot compile])])
802 rm -f conftest.$ac_cv_objext conftest.$ac_ext])
803 AC_SUBST([OBJEXT], [$ac_cv_objext])dnl
804 ac_objext=$OBJEXT
805 ])# _AC_COMPILER_OBJEXT
808 # -------------------- #
809 # 3b. The C compiler. #
810 # -------------------- #
813 # _AC_ARG_VAR_CPPFLAGS
814 # --------------------
815 # Document and register CPPFLAGS, which is used by
816 # AC_PROG_{CC, CPP, CXX, CXXCPP}.
817 AC_DEFUN([_AC_ARG_VAR_CPPFLAGS],
818 [AC_ARG_VAR([CPPFLAGS],
819 [C/C++ preprocessor flags, e.g. -I<include dir> if you have
820 headers in a nonstandard directory <include dir>])])
823 # _AC_ARG_VAR_LDFLAGS
824 # -------------------
825 # Document and register LDFLAGS, which is used by
826 # AC_PROG_{CC, CXX, F77}.
827 AC_DEFUN([_AC_ARG_VAR_LDFLAGS],
828 [AC_ARG_VAR([LDFLAGS],
829 [linker flags, e.g. -L<lib dir> if you have libraries in a
830 nonstandard directory <lib dir>])])
834 # AC_LANG_PREPROC(C)
835 # -------------------
836 # Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
837 AC_DEFUN([AC_LANG_PREPROC(C)],
838 [AC_REQUIRE([AC_PROG_CPP])])
841 # _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT)
842 # -----------------------------------------------
843 # Check if $ac_cpp is a working preprocessor that can flag absent
844 # includes either by the exit status or by warnings.
845 # Set ac_cpp_err to a non-empty value if the preprocessor failed.
846 # This macro is for all languages, not only C.
847 AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE],
848 [ac_preproc_ok=false
849 for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes
850 do
851 # Use a header file that comes with gcc, so configuring glibc
852 # with a fresh cross-compiler works.
853 # On the NeXT, cc -E runs the code through the compiler's parser,
854 # not just through cpp. "Syntax error" is here to catch this case.
855 _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <assert.h>
856 Syntax error]])],
857 [],
858 [# Broken: fails on valid input.
859 continue])
861 # OK, works on sane cases. Now check whether non-existent headers
862 # can be detected and how.
863 _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])],
864 [# Broken: success on invalid input.
865 continue],
866 [# Passes both tests.
867 ac_preproc_ok=:
868 break])
870 done
871 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
872 rm -f conftest.err conftest.$ac_ext
873 AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE
876 # AC_PROG_CPP
877 # -----------
878 # Find a working C preprocessor.
879 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
880 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC.
881 AC_DEFUN([AC_PROG_CPP],
882 [AC_REQUIRE([AC_PROG_CC])dnl
883 AC_ARG_VAR([CPP], [C preprocessor])dnl
884 _AC_ARG_VAR_CPPFLAGS()dnl
885 AC_LANG_PUSH(C)dnl
886 AC_MSG_CHECKING([how to run the C preprocessor])
887 # On Suns, sometimes $CPP names a directory.
888 if test -n "$CPP" && test -d "$CPP"; then
889 CPP=
890 fi
891 if test -z "$CPP"; then
892 AC_CACHE_VAL([ac_cv_prog_CPP],
893 [dnl
894 # Double quotes because CPP needs to be expanded
895 for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
896 do
897 _AC_PROG_PREPROC_WORKS_IFELSE([break])
898 done
899 ac_cv_prog_CPP=$CPP
900 ])dnl
901 CPP=$ac_cv_prog_CPP
902 else
903 ac_cv_prog_CPP=$CPP
904 fi
905 AC_MSG_RESULT([$CPP])
906 _AC_PROG_PREPROC_WORKS_IFELSE([],
907 [AC_MSG_ERROR([C preprocessor "$CPP" fails sanity check])])
908 AC_SUBST(CPP)dnl
909 AC_LANG_POP(C)dnl
910 ])# AC_PROG_CPP
913 # AC_LANG_COMPILER(C)
914 # -------------------
915 # Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
916 AC_DEFUN([AC_LANG_COMPILER(C)],
917 [AC_REQUIRE([AC_PROG_CC])])
920 # ac_cv_prog_gcc
921 # --------------
922 # We used to name the cache variable this way.
923 AU_DEFUN([ac_cv_prog_gcc],
924 [ac_cv_c_compiler_gnu])
927 # AC_PROG_CC([COMPILER ...])
928 # --------------------------
929 # COMPILER ... is a space separated list of C compilers to search for.
930 # This just gives the user an opportunity to specify an alternative
931 # search list for the C compiler.
932 AC_DEFUN([AC_PROG_CC],
933 [AC_LANG_PUSH(C)dnl
934 AC_ARG_VAR([CC], [C compiler command])dnl
935 AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
936 _AC_ARG_VAR_LDFLAGS()dnl
937 _AC_ARG_VAR_CPPFLAGS()dnl
938 m4_ifval([$1],
939 [AC_CHECK_TOOLS(CC, [$1])],
940 [AC_CHECK_TOOL(CC, gcc)
941 if test -z "$CC"; then
942 AC_CHECK_TOOL(CC, cc)
943 fi
944 if test -z "$CC"; then
945 AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
946 fi
947 if test -z "$CC"; then
948 AC_CHECK_TOOLS(CC, cl)
949 fi
950 ])
952 test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
954 # Provide some information about the compiler.
955 echo "$as_me:__oline__:" \
956 "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD
957 ac_compiler=`set X $ac_compile; echo $[2]`
958 _AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD])
959 _AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD])
960 _AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD])
962 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
963 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
964 _AC_LANG_COMPILER_GNU
965 GCC=`test $ac_compiler_gnu = yes && echo yes`
966 _AC_PROG_CC_G
967 # Some people use a C++ compiler to compile C. Since we use `exit',
968 # in C++ we need to declare it. In case someone uses the same compiler
969 # for both compiling C and C++ we need to have the C++ compiler decide
970 # the declaration of exit, since it's the most demanding environment.
971 _AC_COMPILE_IFELSE([@%:@ifndef __cplusplus
972 choke me
973 @%:@endif],
974 [_AC_PROG_CXX_EXIT_DECLARATION])
975 AC_LANG_POP(C)dnl
976 ])# AC_PROG_CC
979 # _AC_PROG_CC_G
980 # -------------
981 # Check whether -g works, even if CFLAGS is set, in case the package
982 # plays around with CFLAGS (such as to build both debugging and normal
983 # versions of a library), tasteless as that idea is.
984 m4_define([_AC_PROG_CC_G],
985 [ac_test_CFLAGS=${CFLAGS+set}
986 ac_save_CFLAGS=$CFLAGS
987 CFLAGS="-g"
988 AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g,
989 [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_prog_cc_g=yes],
990 [ac_cv_prog_cc_g=no])])
991 if test "$ac_test_CFLAGS" = set; then
992 CFLAGS=$ac_save_CFLAGS
993 elif test $ac_cv_prog_cc_g = yes; then
994 if test "$GCC" = yes; then
995 CFLAGS="-g -O2"
996 else
997 CFLAGS="-g"
998 fi
999 else
1000 if test "$GCC" = yes; then
1001 CFLAGS="-O2"
1002 else
1003 CFLAGS=
1004 fi
1005 fi[]dnl
1006 ])# _AC_PROG_CC_G
1009 # AC_PROG_GCC_TRADITIONAL
1010 # -----------------------
1011 AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
1012 [if test $ac_cv_c_compiler_gnu = yes; then
1013 AC_CACHE_CHECK(whether $CC needs -traditional,
1014 ac_cv_prog_gcc_traditional,
1015 [ ac_pattern="Autoconf.*'x'"
1016 AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
1017 Autoconf TIOCGETP],
1018 ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
1020 if test $ac_cv_prog_gcc_traditional = no; then
1021 AC_EGREP_CPP($ac_pattern, [#include <termio.h>
1022 Autoconf TCGETA],
1023 ac_cv_prog_gcc_traditional=yes)
1024 fi])
1025 if test $ac_cv_prog_gcc_traditional = yes; then
1026 CC="$CC -traditional"
1027 fi
1028 fi
1029 ])# AC_PROG_GCC_TRADITIONAL
1032 # AC_PROG_CC_C_O
1033 # --------------
1034 AC_DEFUN([AC_PROG_CC_C_O],
1035 [AC_REQUIRE([AC_PROG_CC])dnl
1036 if test "x$CC" != xcc; then
1037 AC_MSG_CHECKING([whether $CC and cc understand -c and -o together])
1038 else
1039 AC_MSG_CHECKING([whether cc understands -c and -o together])
1040 fi
1041 set dummy $CC; ac_cc=`echo $[2] |
1042 sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
1043 AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
1044 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
1045 # Make sure it works both with $CC and with simple cc.
1046 # We do the test twice because some compilers refuse to overwrite an
1047 # existing .o file with -o, though they will create one.
1048 ac_try='$CC -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
1049 if AC_TRY_EVAL(ac_try) &&
1050 test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try);
1051 then
1052 eval ac_cv_prog_cc_${ac_cc}_c_o=yes
1053 if test "x$CC" != xcc; then
1054 # Test first that cc exists at all.
1055 if AC_TRY_COMMAND(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then
1056 ac_try='cc -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
1057 if AC_TRY_EVAL(ac_try) &&
1058 test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try);
1059 then
1060 # cc works too.
1061 :
1062 else
1063 # cc exists but doesn't like -o.
1064 eval ac_cv_prog_cc_${ac_cc}_c_o=no
1065 fi
1066 fi
1067 fi
1068 else
1069 eval ac_cv_prog_cc_${ac_cc}_c_o=no
1070 fi
1071 rm -f conftest*
1072 ])dnl
1073 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = yes"; then
1074 AC_MSG_RESULT([yes])
1075 else
1076 AC_MSG_RESULT([no])
1077 AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
1078 [Define if your C compiler doesn't accept -c and -o together.])
1079 fi
1080 ])# AC_PROG_CC_C_O
1083 # ---------------------- #
1084 # 3c. The C++ compiler. #
1085 # ---------------------- #
1088 # AC_LANG_PREPROC(C++)
1089 # ---------------------
1090 # Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
1091 AC_DEFUN([AC_LANG_PREPROC(C++)],
1092 [AC_REQUIRE([AC_PROG_CXXCPP])])
1095 # AC_PROG_CXXCPP
1096 # --------------
1097 # Find a working C++ preprocessor.
1098 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
1099 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX.
1100 AC_DEFUN([AC_PROG_CXXCPP],
1101 [AC_REQUIRE([AC_PROG_CXX])dnl
1102 AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl
1103 _AC_ARG_VAR_CPPFLAGS()dnl
1104 AC_LANG_PUSH(C++)dnl
1105 AC_MSG_CHECKING([how to run the C++ preprocessor])
1106 if test -z "$CXXCPP"; then
1107 AC_CACHE_VAL(ac_cv_prog_CXXCPP,
1108 [dnl
1109 # Double quotes because CXXCPP needs to be expanded
1110 for CXXCPP in "$CXX -E" "/lib/cpp"
1111 do
1112 _AC_PROG_PREPROC_WORKS_IFELSE([break])
1113 done
1114 ac_cv_prog_CXXCPP=$CXXCPP
1115 ])dnl
1116 CXXCPP=$ac_cv_prog_CXXCPP
1117 else
1118 ac_cv_prog_CXXCPP=$CXXCPP
1119 fi
1120 AC_MSG_RESULT([$CXXCPP])
1121 _AC_PROG_PREPROC_WORKS_IFELSE([],
1122 [AC_MSG_ERROR([C++ preprocessor "$CXXCPP" fails sanity check])])
1123 AC_SUBST(CXXCPP)dnl
1124 AC_LANG_POP(C++)dnl
1125 ])# AC_PROG_CXXCPP
1128 # AC_LANG_COMPILER(C++)
1129 # ---------------------
1130 # Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
1131 AC_DEFUN([AC_LANG_COMPILER(C++)],
1132 [AC_REQUIRE([AC_PROG_CXX])])
1135 # ac_cv_prog_gxx
1136 # --------------
1137 # We used to name the cache variable this way.
1138 AU_DEFUN([ac_cv_prog_gxx],
1139 [ac_cv_cxx_compiler_gnu])
1142 # AC_PROG_CXX([LIST-OF-COMPILERS])
1143 # --------------------------------
1144 # LIST-OF-COMPILERS is a space separated list of C++ compilers to search
1145 # for (if not specified, a default list is used). This just gives the
1146 # user an opportunity to specify an alternative search list for the C++
1147 # compiler.
1148 # aCC HP-UX C++ compiler much better than `CC', so test before.
1149 # FCC Fujitsu C++ compiler
1150 # KCC KAI C++ compiler
1151 # RCC Rational C++
1152 # xlC_r AIX C Set++ (with support for reentrant code)
1153 # xlC AIX C Set++
1154 AC_DEFUN([AC_PROG_CXX],
1155 [AC_LANG_PUSH(C++)dnl
1156 AC_ARG_VAR([CXX], [C++ compiler command])dnl
1157 AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
1158 _AC_ARG_VAR_LDFLAGS()dnl
1159 _AC_ARG_VAR_CPPFLAGS()dnl
1160 AC_CHECK_TOOLS(CXX,
1161 [$CCC m4_default([$1],
1162 [g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC])],
1163 g++)
1165 # Provide some information about the compiler.
1166 echo "$as_me:__oline__:" \
1167 "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD
1168 ac_compiler=`set X $ac_compile; echo $[2]`
1169 _AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD])
1170 _AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD])
1171 _AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD])
1173 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
1174 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
1175 _AC_LANG_COMPILER_GNU
1176 GXX=`test $ac_compiler_gnu = yes && echo yes`
1177 _AC_PROG_CXX_G
1178 _AC_PROG_CXX_EXIT_DECLARATION
1179 AC_LANG_POP(C++)dnl
1180 ])# AC_PROG_CXX
1183 # _AC_PROG_CXX_G
1184 # --------------
1185 # Check whether -g works, even if CXXFLAGS is set, in case the package
1186 # plays around with CXXFLAGS (such as to build both debugging and
1187 # normal versions of a library), tasteless as that idea is.
1188 m4_define([_AC_PROG_CXX_G],
1189 [ac_test_CXXFLAGS=${CXXFLAGS+set}
1190 ac_save_CXXFLAGS=$CXXFLAGS
1191 CXXFLAGS="-g"
1192 AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g,
1193 [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
1194 [ac_cv_prog_cxx_g=yes],
1195 [ac_cv_prog_cxx_g=no])])
1196 if test "$ac_test_CXXFLAGS" = set; then
1197 CXXFLAGS=$ac_save_CXXFLAGS
1198 elif test $ac_cv_prog_cxx_g = yes; then
1199 if test "$GXX" = yes; then
1200 CXXFLAGS="-g -O2"
1201 else
1202 CXXFLAGS="-g"
1203 fi
1204 else
1205 if test "$GXX" = yes; then
1206 CXXFLAGS="-O2"
1207 else
1208 CXXFLAGS=
1209 fi
1210 fi[]dnl
1211 ])# _AC_PROG_CXX_G
1214 # _AC_PROG_CXX_EXIT_DECLARATION
1215 # -----------------------------
1216 # Find a valid prototype for exit and declare it in confdefs.h.
1217 m4_define([_AC_PROG_CXX_EXIT_DECLARATION],
1218 [for ac_declaration in \
1219 ''\
1220 '#include <stdlib.h>' \
1221 'extern "C" void std::exit (int) throw (); using std::exit;' \
1222 'extern "C" void std::exit (int); using std::exit;' \
1223 'extern "C" void exit (int) throw ();' \
1224 'extern "C" void exit (int);' \
1225 'void exit (int);'
1226 do
1227 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([@%:@include <stdlib.h>
1228 $ac_declaration],
1229 [exit (42);])],
1230 [],
1231 [continue])
1232 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$ac_declaration],
1233 [exit (42);])],
1234 [break])
1235 done
1236 rm -f conftest*
1237 if test -n "$ac_declaration"; then
1238 echo '#ifdef __cplusplus' >>confdefs.h
1239 echo $ac_declaration >>confdefs.h
1240 echo '#endif' >>confdefs.h
1241 fi
1242 ])# _AC_PROG_CXX_EXIT_DECLARATION
1245 # ----------------------------- #
1246 # 3d. The Fortran 77 compiler. #
1247 # ----------------------------- #
1250 # AC_LANG_PREPROC(Fortran 77)
1251 # ---------------------------
1252 # Find the Fortran 77 preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
1253 AC_DEFUN([AC_LANG_PREPROC(Fortran 77)],
1254 [m4_warn([syntax],
1255 [$0: No preprocessor defined for ]_AC_LANG)])
1258 # AC_LANG_COMPILER(Fortran 77)
1259 # ----------------------------
1260 # Find the Fortran 77 compiler. Must be AC_DEFUN'd to be
1261 # AC_REQUIRE'able.
1262 AC_DEFUN([AC_LANG_COMPILER(Fortran 77)],
1263 [AC_REQUIRE([AC_PROG_F77])])
1266 # ac_cv_prog_g77
1267 # --------------
1268 # We used to name the cache variable this way.
1269 AU_DEFUN([ac_cv_prog_g77],
1270 [ac_cv_f77_compiler_gnu])
1273 # AC_PROG_F77([COMPILERS...])
1274 # ---------------------------
1275 # COMPILERS is a space separated list of Fortran 77 compilers to search
1276 # for.
1277 # Fortran 95 isn't strictly backwards-compatiable with Fortran 77, but
1278 # `f95' is worth trying.
1279 #
1280 # Compilers are ordered by
1281 # 1. F77, F90, F95
1282 # 2. Good/tested native compilers, bad/untested native compilers
1283 # 3. Wrappers around f2c go last.
1284 #
1285 # `fort77' and `fc' are wrappers around `f2c', `fort77' being better.
1286 # It is believed that under HP-UX `fort77' is the name of the native
1287 # compiler. On some Cray systems, fort77 is a native compiler.
1288 # cf77 and cft77 are (older) Cray F77 compilers.
1289 # frt is the Fujitsu F77 compiler.
1290 # pgf77 and pgf90 are the Portland Group F77 and F90 compilers.
1291 # xlf/xlf90/xlf95 are IBM (AIX) F77/F90/F95 compilers.
1292 # lf95 is the Lahey-Fujitsu compiler.
1293 # fl32 is the Microsoft Fortran "PowerStation" compiler.
1294 # af77 is the Apogee F77 compiler for Intergraph hardware running CLIX.
1295 # epcf90 is the "Edinburgh Portable Compiler" F90.
1296 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1297 AC_DEFUN([AC_PROG_F77],
1298 [AC_LANG_PUSH(Fortran 77)dnl
1299 AC_ARG_VAR([F77], [Fortran 77 compiler command])dnl
1300 AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl
1301 _AC_ARG_VAR_LDFLAGS()dnl
1302 AC_CHECK_TOOLS(F77,
1303 [m4_default([$1],
1304 [g77 f77 xlf cf77 cft77 frt pgf77 fl32 af77 fort77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 lf95 g95 fc])])
1306 # Provide some information about the compiler.
1307 echo "$as_me:__oline__:" \
1308 "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD
1309 ac_compiler=`set X $ac_compile; echo $[2]`
1310 _AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD])
1311 _AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD])
1312 _AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD])
1314 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
1315 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
1316 # If we don't use `.F' as extension, the preprocessor is not run on the
1317 # input file.
1318 ac_save_ext=$ac_ext
1319 ac_ext=F
1320 _AC_LANG_COMPILER_GNU
1321 ac_ext=$ac_save_ext
1322 G77=`test $ac_compiler_gnu = yes && echo yes`
1323 _AC_PROG_F77_G
1324 AC_LANG_POP(Fortran 77)dnl
1325 ])# AC_PROG_F77
1328 # _AC_PROG_F77_G
1329 # --------------
1330 # Check whether -g works, even if FFLAGS is set, in case the package
1331 # plays around with FFLAGS (such as to build both debugging and normal
1332 # versions of a library), tasteless as that idea is.
1333 m4_define([_AC_PROG_F77_G],
1334 [ac_test_FFLAGS=${FFLAGS+set}
1335 ac_save_FFLAGS=$FFLAGS
1336 FFLAGS=
1337 AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g,
1338 [FFLAGS=-g
1339 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
1340 [ac_cv_prog_f77_g=yes],
1341 [ac_cv_prog_f77_g=no])
1342 ])
1343 if test "$ac_test_FFLAGS" = set; then
1344 FFLAGS=$ac_save_FFLAGS
1345 elif test $ac_cv_prog_f77_g = yes; then
1346 if test "$G77" = yes; then
1347 FFLAGS="-g -O2"
1348 else
1349 FFLAGS="-g"
1350 fi
1351 else
1352 if test "$G77" = yes; then
1353 FFLAGS="-O2"
1354 else
1355 FFLAGS=
1356 fi
1357 fi[]dnl
1358 ])# _AC_PROG_F77_G
1361 # AC_PROG_F77_C_O
1362 # ---------------
1363 # Test if the Fortran 77 compiler accepts the options `-c' and `-o'
1364 # simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not.
1365 #
1366 # The usefulness of this macro is questionable, as I can't really see
1367 # why anyone would use it. The only reason I include it is for
1368 # completeness, since a similar test exists for the C compiler.
1369 AC_DEFUN([AC_PROG_F77_C_O],
1370 [AC_REQUIRE([AC_PROG_F77])dnl
1371 AC_CACHE_CHECK([whether $F77 understand -c and -o together],
1372 [ac_cv_prog_f77_c_o],
1373 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
1374 # We test twice because some compilers refuse to overwrite an existing
1375 # `.o' file with `-o', although they will create one.
1376 ac_try='$F77 $FFLAGS -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
1377 if AC_TRY_EVAL(ac_try) &&
1378 test -f conftest.$ac_objext &&
1379 AC_TRY_EVAL(ac_try); then
1380 ac_cv_prog_f77_c_o=yes
1381 else
1382 ac_cv_prog_f77_c_o=no
1383 fi
1384 rm -f conftest*])
1385 if test $ac_cv_prog_f77_c_o = no; then
1386 AC_DEFINE(F77_NO_MINUS_C_MINUS_O, 1,
1387 [Define if your Fortran 77 compiler doesn't accept -c and -o together.])
1388 fi
1389 ])# AC_PROG_F77_C_O
1395 ## ------------------------------- ##
1396 ## 4. Compilers' characteristics. ##
1397 ## ------------------------------- ##
1400 # -------------------------------- #
1401 # 4b. C compiler characteristics. #
1402 # -------------------------------- #
1404 # AC_PROG_CC_STDC
1405 # ---------------
1406 # If the C compiler in not in ANSI C mode by default, try to add an
1407 # option to output variable @code{CC} to make it so. This macro tries
1408 # various options that select ANSI C on some system or another. It
1409 # considers the compiler to be in ANSI C mode if it handles function
1410 # prototypes correctly.
1411 AC_DEFUN([AC_PROG_CC_STDC],
1412 [AC_REQUIRE([AC_PROG_CC])dnl
1413 AC_BEFORE([$0], [AC_C_INLINE])dnl
1414 AC_BEFORE([$0], [AC_C_CONST])dnl
1415 dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require
1416 dnl a magic option to avoid problems with ANSI preprocessor commands
1417 dnl like #elif.
1418 dnl FIXME: can't do this because then AC_AIX won't work due to a
1419 dnl circular dependency.
1420 dnl AC_BEFORE([$0], [AC_PROG_CPP])
1421 AC_MSG_CHECKING([for $CC option to accept ANSI C])
1422 AC_CACHE_VAL(ac_cv_prog_cc_stdc,
1423 [ac_cv_prog_cc_stdc=no
1424 ac_save_CC=$CC
1425 AC_LANG_CONFTEST([AC_LANG_PROGRAM(
1426 [[#include <stdarg.h>
1427 #include <stdio.h>
1428 #include <sys/types.h>
1429 #include <sys/stat.h>
1430 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
1431 struct buf { int x; };
1432 FILE * (*rcsopen) (struct buf *, struct stat *, int);
1433 static char *e (p, i)
1434 char **p;
1435 int i;
1436 {
1437 return p[i];
1438 }
1439 static char *f (char * (*g) (char **, int), char **p, ...)
1440 {
1441 char *s;
1442 va_list v;
1443 va_start (v,p);
1444 s = g (p, va_arg (v,int));
1445 va_end (v);
1446 return s;
1447 }
1448 int test (int i, double x);
1449 struct s1 {int (*f) (int a);};
1450 struct s2 {int (*f) (double a);};
1451 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
1452 int argc;
1453 char **argv;]],
1454 [[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]])])
1455 # Don't try gcc -ansi; that turns off useful extensions and
1456 # breaks some systems' header files.
1457 # AIX -qlanglvl=ansi
1458 # Ultrix and OSF/1 -std1
1459 # HP-UX 10.20 and later -Ae
1460 # HP-UX older versions -Aa -D_HPUX_SOURCE
1461 # SVR4 -Xc -D__EXTENSIONS__
1462 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
1463 do
1464 CC="$ac_save_CC $ac_arg"
1465 AC_COMPILE_IFELSE([],
1466 [ac_cv_prog_cc_stdc=$ac_arg
1467 break])
1468 done
1469 rm -f conftest.$ac_ext conftest.$ac_objext
1470 CC=$ac_save_CC
1471 ])
1472 case "x$ac_cv_prog_cc_stdc" in
1473 x|xno)
1474 AC_MSG_RESULT([none needed]) ;;
1475 *)
1476 AC_MSG_RESULT([$ac_cv_prog_cc_stdc])
1477 CC="$CC $ac_cv_prog_cc_stdc" ;;
1478 esac
1479 ])# AC_PROG_CC_STDC
1482 # AC_C_CROSS
1483 # ----------
1484 # Has been merged into AC_PROG_CC.
1485 AU_DEFUN([AC_C_CROSS], [])
1488 # AC_C_CHAR_UNSIGNED
1489 # ------------------
1490 AC_DEFUN([AC_C_CHAR_UNSIGNED],
1491 [AH_VERBATIM([__CHAR_UNSIGNED__],
1492 [/* Define if type `char' is unsigned and you are not using gcc. */
1493 #ifndef __CHAR_UNSIGNED__
1494 # undef __CHAR_UNSIGNED__
1495 #endif])dnl
1496 AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
1497 [AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
1498 [((char) -1) < 0])],
1499 ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
1500 if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
1501 AC_DEFINE(__CHAR_UNSIGNED__)
1502 fi
1503 ])# AC_C_CHAR_UNSIGNED
1506 # AC_C_LONG_DOUBLE
1507 # ----------------
1508 AC_DEFUN([AC_C_LONG_DOUBLE],
1509 [AC_CACHE_CHECK(for long double, ac_cv_c_long_double,
1510 [if test "$GCC" = yes; then
1511 ac_cv_c_long_double=yes
1512 else
1513 AC_TRY_RUN(
1514 [int
1515 main ()
1516 {
1517 /* The Stardent Vistra knows sizeof(long double), but does not
1518 support it. */
1519 long double foo = 0.0;
1520 /* On Ultrix 4.3 cc, long double is 4 and double is 8. */
1521 exit (sizeof (long double) < sizeof (double));
1522 }],
1523 ac_cv_c_long_double=yes, ac_cv_c_long_double=no)
1524 fi])
1525 if test $ac_cv_c_long_double = yes; then
1526 AC_DEFINE(HAVE_LONG_DOUBLE, 1,
1527 [Define if the `long double' type works.])
1528 fi
1529 ])# AC_C_LONG_DOUBLE
1532 # AC_C_BIGENDIAN
1533 # --------------
1534 AC_DEFUN([AC_C_BIGENDIAN],
1535 [AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
1536 [ac_cv_c_bigendian=unknown
1537 # See if sys/param.h defines the BYTE_ORDER macro.
1538 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1539 #include <sys/param.h>
1540 ],
1541 [#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
1542 bogus endian macros
1543 #endif
1544 ])],
1545 [# It does; now see whether it defined to BIG_ENDIAN or not.
1546 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1547 #include <sys/param.h>
1548 ], [#if BYTE_ORDER != BIG_ENDIAN
1549 not big endian
1550 #endif
1551 ])], [ac_cv_c_bigendian=yes],
1552 [ac_cv_c_bigendian=no])])
1553 if test $ac_cv_c_bigendian = unknown; then
1554 AC_TRY_RUN(
1555 [int
1556 main ()
1557 {
1558 /* Are we little or big endian? From Harbison&Steele. */
1559 union
1560 {
1561 long l;
1562 char c[sizeof (long)];
1563 } u;
1564 u.l = 1;
1565 exit (u.c[sizeof (long) - 1] == 1);
1566 }], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes)
1567 fi])
1568 if test $ac_cv_c_bigendian = yes; then
1569 AC_DEFINE(WORDS_BIGENDIAN, 1,
1570 [Define if your processor stores words with the most significant
1571 byte first (like Motorola and SPARC, unlike Intel and VAX).])
1572 fi
1573 ])# AC_C_BIGENDIAN
1576 # AC_C_INLINE
1577 # -----------
1578 # Do nothing if the compiler accepts the inline keyword.
1579 # Otherwise define inline to __inline__ or __inline if one of those work,
1580 # otherwise define inline to be empty.
1581 AC_DEFUN([AC_C_INLINE],
1582 [AC_REQUIRE([AC_PROG_CC_STDC])dnl
1583 AC_CACHE_CHECK([for inline], ac_cv_c_inline,
1584 [ac_cv_c_inline=no
1585 for ac_kw in inline __inline__ __inline; do
1586 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1587 [#ifndef __cplusplus
1588 static $ac_kw int static_foo () {return 0; }
1589 $ac_kw int foo () {return 0; }
1590 #endif
1591 ])],
1592 [ac_cv_c_inline=$ac_kw; break])
1593 done
1594 ])
1595 case $ac_cv_c_inline in
1596 inline | yes) ;;
1597 no) AC_DEFINE(inline,,
1598 [Define as `__inline' if that's what the C compiler calls it,
1599 or to nothing if it is not supported.]) ;;
1600 *) AC_DEFINE_UNQUOTED(inline, $ac_cv_c_inline) ;;
1601 esac
1602 ])# AC_C_INLINE
1605 # AC_C_CONST
1606 # ----------
1607 AC_DEFUN([AC_C_CONST],
1608 [AC_REQUIRE([AC_PROG_CC_STDC])dnl
1609 AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
1610 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1611 [[/* FIXME: Include the comments suggested by Paul. */
1612 #ifndef __cplusplus
1613 /* Ultrix mips cc rejects this. */
1614 typedef int charset[2];
1615 const charset x;
1616 /* SunOS 4.1.1 cc rejects this. */
1617 char const *const *ccp;
1618 char **p;
1619 /* NEC SVR4.0.2 mips cc rejects this. */
1620 struct point {int x, y;};
1621 static struct point const zero = {0,0};
1622 /* AIX XL C 1.02.0.0 rejects this.
1623 It does not let you subtract one const X* pointer from another in
1624 an arm of an if-expression whose if-part is not a constant
1625 expression */
1626 const char *g = "string";
1627 ccp = &g + (g ? g-g : 0);
1628 /* HPUX 7.0 cc rejects these. */
1629 ++ccp;
1630 p = (char**) ccp;
1631 ccp = (char const *const *) p;
1632 { /* SCO 3.2v4 cc rejects this. */
1633 char *t;
1634 char const *s = 0 ? (char *) 0 : (char const *) 0;
1636 *t++ = 0;
1637 }
1638 { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
1639 int x[] = {25, 17};
1640 const int *foo = &x[0];
1641 ++foo;
1642 }
1643 { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
1644 typedef const int *iptr;
1645 iptr p = 0;
1646 ++p;
1647 }
1648 { /* AIX XL C 1.02.0.0 rejects this saying
1649 "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
1650 struct s { int j; const int *ap[3]; };
1651 struct s *b; b->j = 5;
1652 }
1653 { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
1654 const int foo = 10;
1655 }
1656 #endif
1657 ]])],
1658 [ac_cv_c_const=yes],
1659 [ac_cv_c_const=no])])
1660 if test $ac_cv_c_const = no; then
1661 AC_DEFINE(const,,
1662 [Define to empty if `const' does not conform to ANSI C.])
1663 fi
1664 ])# AC_C_CONST
1667 # AC_C_VOLATILE
1668 # -------------
1669 # Note that, unlike const, #defining volatile to be the empty string can
1670 # actually turn a correct program into an incorrect one, since removing
1671 # uses of volatile actually grants the compiler permission to perform
1672 # optimizations that could break the user's code. So, do not #define
1673 # volatile away unless it is really necessary to allow the user's code
1674 # to compile cleanly. Benign compiler failures should be tolerated.
1675 AC_DEFUN([AC_C_VOLATILE],
1676 [AC_REQUIRE([AC_PROG_CC_STDC])dnl
1677 AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
1678 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1679 volatile int x;
1680 int * volatile y;])],
1681 [ac_cv_c_volatile=yes],
1682 [ac_cv_c_volatile=no])])
1683 if test $ac_cv_c_volatile = no; then
1684 AC_DEFINE(volatile,,
1685 [Define to empty if the keyword `volatile' does not work.
1686 Warning: valid code using `volatile' can become incorrect
1687 without. Disable with care.])
1688 fi
1689 ])# AC_C_VOLATILE
1692 # AC_C_STRINGIZE
1693 # --------------
1694 # Checks if `#' can be used to glue strings together at the CPP level.
1695 # Defines HAVE_STRINGIZE if positive.
1696 AC_DEFUN([AC_C_STRINGIZE],
1697 [AC_CACHE_CHECK([for preprocessor stringizing operator],
1698 [ac_cv_c_stringize],
1699 [AC_EGREP_CPP([@%:@teststring],
1700 [@%:@define x(y) #y
1702 char *s = x(teststring);],
1703 [ac_cv_c_stringize=no],
1704 [ac_cv_c_stringize=yes])])
1705 if test $ac_cv_c_stringize = yes; then
1706 AC_DEFINE(HAVE_STRINGIZE, 1,
1707 [Define if cpp supports the ANSI @%:@ stringizing operator.])
1708 fi
1709 ])# AC_C_STRINGIZE
1712 # AC_C_PROTOTYPES
1713 # ---------------
1714 # Check if the C compiler supports prototypes, included if it needs
1715 # options.
1716 AC_DEFUN([AC_C_PROTOTYPES],
1717 [AC_REQUIRE([AC_PROG_CC_STDC])dnl
1718 AC_MSG_CHECKING([for function prototypes])
1719 if test "$ac_cv_prog_cc_stdc" != no; then
1720 AC_MSG_RESULT([yes])
1721 AC_DEFINE(PROTOTYPES, 1,
1722 [Define if the C compiler supports function prototypes.])
1723 else
1724 AC_MSG_RESULT([no])
1725 fi
1726 ])# AC_C_PROTOTYPES
1731 # ---------------------------------------- #
1732 # 4d. Fortan 77 compiler characteristics. #
1733 # ---------------------------------------- #
1736 # _AC_PROG_F77_V_OUTPUT([FLAG = $ac_cv_prog_f77_v])
1737 # -------------------------------------------------
1738 # Link a trivial Fortran program, compiling with a verbose output FLAG
1739 # (which default value, $ac_cv_prog_f77_v, is computed by
1740 # _AC_PROG_F77_V), and return the output in $ac_f77_v_output. This
1741 # output is processed in the way expected by AC_F77_LIBRARY_LDFLAGS,
1742 # so that any link flags that are echoed by the compiler appear as
1743 # space-separated items.
1744 AC_DEFUN([_AC_PROG_F77_V_OUTPUT],
1745 [AC_REQUIRE([AC_PROG_F77])dnl
1746 AC_LANG_PUSH(Fortran 77)dnl
1748 AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
1750 # Compile and link our simple test program by passing a flag (argument
1751 # 1 to this macro) to the Fortran 77 compiler in order to get
1752 # "verbose" output that we can then parse for the Fortran 77 linker
1753 # flags.
1754 ac_save_FFLAGS=$FFLAGS
1755 FFLAGS="$FFLAGS m4_default([$1], [$ac_cv_prog_f77_v])"
1756 (eval echo $as_me:__oline__: \"$ac_link\") >&AS_MESSAGE_LOG_FD
1757 ac_f77_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | grep -v 'Driving:'`
1758 echo "$ac_f77_v_output" >&AS_MESSAGE_LOG_FD
1759 FFLAGS=$ac_save_FFLAGS
1761 rm -f conftest*
1762 AC_LANG_POP(Fortran 77)dnl
1764 # If we are using xlf then replace all the commas with spaces.
1765 if echo $ac_f77_v_output | grep xlfentry >/dev/null 2>&1; then
1766 ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'`
1767 fi
1769 # If we are using Cray Fortran then delete quotes.
1770 # Use "\"" instead of '"' for font-lock-mode.
1771 # FIXME: a more general fix for quoted arguments with spaces?
1772 if echo $ac_f77_v_output | grep cft90 >/dev/null 2>&1; then
1773 ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"`
1774 fi[]dnl
1775 ])# _AC_PROG_F77_V_OUTPUT
1778 # _AC_PROG_F77_V
1779 # --------------
1780 #
1781 # Determine the flag that causes the Fortran 77 compiler to print
1782 # information of library and object files (normally -v)
1783 # Needed for AC_F77_LIBRARY_FLAGS
1784 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1785 AC_DEFUN([_AC_PROG_F77_V],
1786 [AC_CACHE_CHECK([how to get verbose linking output from $F77],
1787 [ac_cv_prog_f77_v],
1788 [AC_LANG_ASSERT(Fortran 77)
1789 AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
1790 [ac_cv_prog_f77_v=
1791 # Try some options frequently used verbose output
1792 for ac_verb in -v -verbose --verbose -V -\#\#\#; do
1793 _AC_PROG_F77_V_OUTPUT($ac_verb)
1794 # look for -l* and *.a constructs in the output
1795 for ac_arg in $ac_f77_v_output; do
1796 case $ac_arg in
1797 [[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*)
1798 ac_cv_prog_f77_v=$ac_verb
1799 break 2 ;;
1800 esac
1801 done
1802 done
1803 if test -z "$ac_cv_prog_f77_v"; then
1804 AC_MSG_WARN([cannot determine how to obtain linking information from $F77])
1805 fi],
1806 [AC_MSG_WARN([compilation failed])])
1807 ])])# _AC_PROG_F77_V
1810 # AC_F77_LIBRARY_LDFLAGS
1811 # ----------------------
1812 #
1813 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 77
1814 # intrinsic and run-time libraries that are required to successfully
1815 # link a Fortran 77 program or shared library. The output variable
1816 # FLIBS is set to these flags.
1817 #
1818 # This macro is intended to be used in those situations when it is
1819 # necessary to mix, e.g. C++ and Fortran 77, source code into a single
1820 # program or shared library.
1821 #
1822 # For example, if object files from a C++ and Fortran 77 compiler must
1823 # be linked together, then the C++ compiler/linker must be used for
1824 # linking (since special C++-ish things need to happen at link time
1825 # like calling global constructors, instantiating templates, enabling
1826 # exception support, etc.).
1827 #
1828 # However, the Fortran 77 intrinsic and run-time libraries must be
1829 # linked in as well, but the C++ compiler/linker doesn't know how to
1830 # add these Fortran 77 libraries. Hence, the macro
1831 # "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran 77
1832 # libraries.
1833 #
1834 # This macro was packaged in its current form by Matthew D. Langston.
1835 # However, nearly all of this macro came from the "OCTAVE_FLIBS" macro
1836 # in "octave-2.0.13/aclocal.m4", and full credit should go to John
1837 # W. Eaton for writing this extremely useful macro. Thank you John.
1838 AC_DEFUN([AC_F77_LIBRARY_LDFLAGS],
1839 [AC_LANG_PUSH(Fortran 77)dnl
1840 _AC_PROG_F77_V
1841 AC_CACHE_CHECK([for Fortran 77 libraries], ac_cv_flibs,
1842 [if test "x$FLIBS" != "x"; then
1843 ac_cv_flibs="$FLIBS" # Let the user override the test.
1844 else
1846 _AC_PROG_F77_V_OUTPUT
1848 ac_cv_flibs=
1850 # Save positional arguments (if any)
1851 ac_save_positional="$[@]"
1853 set X $ac_f77_v_output
1854 while test $[@%:@] != 1; do
1855 shift
1856 ac_arg=$[1]
1857 case $ac_arg in
1858 [[\\/]]*.a | ?:[[\\/]]*.a)
1859 AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, ,
1860 ac_cv_flibs="$ac_cv_flibs $ac_arg")
1861 ;;
1862 -bI:*)
1863 AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, ,
1864 [AC_LINKER_OPTION([$ac_arg], ac_cv_flibs)])
1865 ;;
1866 # Ignore these flags.
1867 -lang* | -lcrt0.o | -lc | -lgcc | -LANG:=*)
1868 ;;
1869 -lkernel32)
1870 test x"$CYGWIN" != xyes && ac_cv_flibs="$ac_cv_flibs $ac_arg"
1871 ;;
1872 -[[LRuY]])
1873 # These flags, when seen by themselves, take an argument.
1874 # We remove the space between option and argument and re-iterate
1875 # unless we find an empty arg or a new option (starting with -)
1876 case $[2] in
1877 "" | -*);;
1878 *)
1879 ac_arg="$ac_arg$[2]"
1880 shift; shift
1881 set X $ac_arg "$[@]"
1882 ;;
1883 esac
1884 ;;
1885 -YP,*)
1886 for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
1887 AC_LIST_MEMBER_OF($ac_j, $ac_cv_flibs, ,
1888 [ac_arg="$ac_arg $ac_j"
1889 ac_cv_flibs="$ac_cv_flibs $ac_j"])
1890 done
1891 ;;
1892 -[[lLR]]*)
1893 AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, ,
1894 ac_cv_flibs="$ac_cv_flibs $ac_arg")
1895 ;;
1896 # Ignore everything else.
1897 esac
1898 done
1899 # restore positional arguments
1900 set X $ac_save_positional; shift
1902 # We only consider "LD_RUN_PATH" on Solaris systems. If this is seen,
1903 # then we insist that the "run path" must be an absolute path (i.e. it
1904 # must begin with a "/").
1905 case `(uname -sr) 2>/dev/null` in
1906 "SunOS 5"*)
1907 ac_ld_run_path=`echo $ac_f77_v_output |
1908 sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'`
1909 test "x$ac_ld_run_path" != x &&
1910 AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_flibs)
1911 ;;
1912 esac
1913 fi # test "x$FLIBS" = "x"
1914 ])
1915 FLIBS="$ac_cv_flibs"
1916 AC_SUBST(FLIBS)
1917 AC_LANG_POP(Fortran 77)dnl
1918 ])# AC_F77_LIBRARY_LDFLAGS
1921 # AC_F77_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1922 # -----------------------------------------------------------
1923 #
1924 # Detect name of dummy main routine required by the Fortran libraries,
1925 # (if any) and define F77_DUMMY_MAIN to this name (which should be
1926 # used for a dummy declaration, if it is defined). On some systems,
1927 # linking a C program to the Fortran library does not work unless you
1928 # supply a dummy function called something like MAIN__.
1929 #
1930 # Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C
1931 # program with the F77 libs is found; default to exiting with an error
1932 # message. Execute ACTION-IF-FOUND if a dummy routine name is needed
1933 # and found or if it is not needed (default to defining F77_DUMMY_MAIN
1934 # when needed).
1935 #
1936 # What is technically happening is that the Fortran libraries provide
1937 # their own main() function, which usually initializes Fortran I/O and
1938 # similar stuff, and then calls MAIN__, which is the entry point of
1939 # your program. Usually, a C program will override this with its own
1940 # main() routine, but the linker sometimes complain if you don't
1941 # provide a dummy (never-called) MAIN__ routine anyway.
1942 #
1943 # Of course, programs that want to allow Fortran subroutines to do
1944 # I/O, etcetera, should call their main routine MAIN__() (or whatever)
1945 # instead of main(). A separate autoconf test (AC_F77_MAIN) checks
1946 # for the routine to use in this case (since the semantics of the test
1947 # are slightly different). To link to e.g. purely numerical
1948 # libraries, this is normally not necessary, however, and most C/C++
1949 # programs are reluctant to turn over so much control to Fortran. =)
1950 #
1951 # The name variants we check for are (in order):
1952 # MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional)
1953 # MAIN_, __main (SunOS)
1954 # MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too)
1955 AC_DEFUN([AC_F77_DUMMY_MAIN],
1956 [AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
1957 m4_define([_AC_LANG_PROGRAM_C_F77_HOOKS],
1958 [#ifdef F77_DUMMY_MAIN
1959 # ifdef __cplusplus
1960 extern "C"
1961 # endif
1962 int F77_DUMMY_MAIN() { return 1; }
1963 #endif
1964 ])
1965 AC_CACHE_CHECK([for dummy main to link with Fortran 77 libraries],
1966 ac_cv_f77_dummy_main,
1967 [AC_LANG_PUSH(C)dnl
1968 ac_f77_dm_save_LIBS=$LIBS
1969 LIBS="$LIBS $FLIBS"
1971 # First, try linking without a dummy main:
1972 AC_TRY_LINK([], [],
1973 ac_cv_f77_dummy_main=none,
1974 ac_cv_f77_dummy_main=unknown)
1976 if test $ac_cv_f77_dummy_main = unknown; then
1977 for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
1978 AC_TRY_LINK([@%:@define F77_DUMMY_MAIN $ac_func],
1979 [], [ac_cv_f77_dummy_main=$ac_func; break])
1980 done
1981 fi
1982 rm -f conftest*
1983 LIBS=$ac_f77_dm_save_LIBS
1984 AC_LANG_POP(C)dnl
1985 ])
1986 F77_DUMMY_MAIN=$ac_cv_f77_dummy_main
1987 AS_IF([test "$F77_DUMMY_MAIN" != unknown],
1988 [m4_default([$1],
1989 [if test $F77_DUMMY_MAIN != none; then
1990 AC_DEFINE_UNQUOTED([F77_DUMMY_MAIN], $F77_DUMMY_MAIN,
1991 [Define to dummy `main' function (if any) required to
1992 link to the Fortran 77 libraries.])
1993 fi])],
1994 [m4_default([$2],
1995 [AC_MSG_ERROR([Linking to Fortran libraries from C fails.])])])
1996 ])# AC_F77_DUMMY_MAIN
1999 # AC_F77_MAIN
2000 # -----------
2001 # Define F77_MAIN to name of alternate main() function for use with
2002 # the Fortran libraries. (Typically, the libraries may define their
2003 # own main() to initialize I/O, etcetera, that then call your own
2004 # routine called MAIN__ or whatever.) See AC_F77_DUMMY_MAIN, above.
2005 # If no such alternate name is found, just define F77_MAIN to main.
2006 #
2007 AC_DEFUN([AC_F77_MAIN],
2008 [AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
2009 AC_CACHE_CHECK([for alternate main to link with Fortran 77 libraries],
2010 ac_cv_f77_main,
2011 [AC_LANG_PUSH(C)dnl
2012 ac_f77_m_save_LIBS=$LIBS
2013 LIBS="$LIBS $FLIBS"
2014 ac_cv_f77_main="main" # default entry point name
2016 for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
2017 AC_TRY_LINK([#undef F77_DUMMY_MAIN
2018 @%:@define main $ac_func], [], [ac_cv_f77_main=$ac_func; break])
2019 done
2020 rm -f conftest*
2021 LIBS=$ac_f77_m_save_LIBS
2022 AC_LANG_POP(C)dnl
2023 ])
2024 AC_DEFINE_UNQUOTED([F77_MAIN], $ac_cv_f77_main,
2025 [Define to alternate name for `main' routine that is
2026 called from a `main' in the Fortran libraries.])
2027 ])# AC_F77_MAIN
2030 # _AC_F77_NAME_MANGLING
2031 # ---------------------
2032 # Test for the name mangling scheme used by the Fortran 77 compiler.
2033 #
2034 # Sets ac_cv_f77_mangling. The value contains three fields, separated
2035 # by commas:
2036 #
2037 # lower case / upper case:
2038 # case translation of the Fortan 77 symbols
2039 # underscore / no underscore:
2040 # whether the compiler appends "_" to symbol names
2041 # extra underscore / no extra underscore:
2042 # whether the compiler appends an extra "_" to symbol names already
2043 # containing at least one underscore
2044 #
2045 AC_DEFUN([_AC_F77_NAME_MANGLING],
2046 [AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
2047 AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl
2048 AC_CACHE_CHECK([for Fortran 77 name-mangling scheme],
2049 ac_cv_f77_mangling,
2050 [AC_LANG_PUSH(Fortran 77)dnl
2051 AC_COMPILE_IFELSE(
2052 [ subroutine foobar()
2053 return
2054 end
2055 subroutine foo_bar()
2056 return
2057 end],
2058 [mv conftest.$ac_objext cf77_test.$ac_objext
2060 AC_LANG_PUSH(C)dnl
2062 ac_save_LIBS=$LIBS
2063 LIBS="cf77_test.$ac_objext $LIBS $FLIBS"
2065 ac_success=no
2066 for ac_foobar in foobar FOOBAR; do
2067 for ac_underscore in "" "_"; do
2068 ac_func="$ac_foobar$ac_underscore"
2069 AC_TRY_LINK_FUNC($ac_func,
2070 [ac_success=yes; break 2])
2071 done
2072 done
2074 if test "$ac_success" = "yes"; then
2075 case $ac_foobar in
2076 foobar)
2077 ac_case=lower
2078 ac_foo_bar=foo_bar
2079 ;;
2080 FOOBAR)
2081 ac_case=upper
2082 ac_foo_bar=FOO_BAR
2083 ;;
2084 esac
2086 ac_success_extra=no
2087 for ac_extra in "" "_"; do
2088 ac_func="$ac_foo_bar$ac_underscore$ac_extra"
2089 AC_TRY_LINK_FUNC($ac_func,
2090 [ac_success_extra=yes; break])
2091 done
2093 if test "$ac_success_extra" = "yes"; then
2094 ac_cv_f77_mangling="$ac_case case"
2095 if test -z "$ac_underscore"; then
2096 ac_cv_f77_mangling="$ac_cv_f77_mangling, no underscore"
2097 else
2098 ac_cv_f77_mangling="$ac_cv_f77_mangling, underscore"
2099 fi
2100 if test -z "$ac_extra"; then
2101 ac_cv_f77_mangling="$ac_cv_f77_mangling, no extra underscore"
2102 else
2103 ac_cv_f77_mangling="$ac_cv_f77_mangling, extra underscore"
2104 fi
2105 else
2106 ac_cv_f77_mangling="unknown"
2107 fi
2108 else
2109 ac_cv_f77_mangling="unknown"
2110 fi
2112 LIBS=$ac_save_LIBS
2113 AC_LANG_POP(C)dnl
2114 rm -f cf77_test* conftest*])
2115 AC_LANG_POP(Fortran 77)dnl
2116 ])
2117 ])# _AC_F77_NAME_MANGLING
2119 # The replacement is empty.
2120 AU_DEFUN([AC_F77_NAME_MANGLING], [])
2123 # AC_F77_WRAPPERS
2124 # ---------------
2125 # Defines C macros F77_FUNC(name,NAME) and F77_FUNC_(name,NAME) to
2126 # properly mangle the names of C identifiers, and C identifiers with
2127 # underscores, respectively, so that they match the name mangling
2128 # scheme used by the Fortran 77 compiler.
2129 AC_DEFUN([AC_F77_WRAPPERS],
2130 [AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
2131 AH_TEMPLATE([F77_FUNC],
2132 [Define to a macro mangling the given C identifier (in lower and upper
2133 case), which must not contain underscores, for linking with Fortran.])dnl
2134 AH_TEMPLATE([F77_FUNC_],
2135 [As F77_FUNC, but for C identifiers containing underscores.])dnl
2136 case $ac_cv_f77_mangling in
2137 "lower case, no underscore, no extra underscore")
2138 AC_DEFINE([F77_FUNC(name,NAME)], [name])
2139 AC_DEFINE([F77_FUNC_(name,NAME)], [name]) ;;
2140 "lower case, no underscore, extra underscore")
2141 AC_DEFINE([F77_FUNC(name,NAME)], [name])
2142 AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;;
2143 "lower case, underscore, no extra underscore")
2144 AC_DEFINE([F77_FUNC(name,NAME)], [name ## _])
2145 AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;;
2146 "lower case, underscore, extra underscore")
2147 AC_DEFINE([F77_FUNC(name,NAME)], [name ## _])
2148 AC_DEFINE([F77_FUNC_(name,NAME)], [name ## __]) ;;
2149 "upper case, no underscore, no extra underscore")
2150 AC_DEFINE([F77_FUNC(name,NAME)], [NAME])
2151 AC_DEFINE([F77_FUNC_(name,NAME)], [NAME]) ;;
2152 "upper case, no underscore, extra underscore")
2153 AC_DEFINE([F77_FUNC(name,NAME)], [NAME])
2154 AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;;
2155 "upper case, underscore, no extra underscore")
2156 AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _])
2157 AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;;
2158 "upper case, underscore, extra underscore")
2159 AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _])
2160 AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## __]) ;;
2161 *)
2162 AC_MSG_WARN([unknown Fortran 77 name-mangling scheme])
2163 ;;
2164 esac
2165 ])# AC_F77_WRAPPERS
2168 # AC_F77_FUNC(NAME, [SHELLVAR = NAME])
2169 # ------------------------------------
2170 # For a Fortran subroutine of given NAME, define a shell variable
2171 # $SHELLVAR to the Fortran-77 mangled name. If the SHELLVAR
2172 # argument is not supplied, it defaults to NAME.
2173 AC_DEFUN([AC_F77_FUNC],
2174 [AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
2175 case $ac_cv_f77_mangling in
2176 upper*) ac_val="m4_toupper([$1])" ;;
2177 lower*) ac_val="m4_tolower([$1])" ;;
2178 *) ac_val="unknown" ;;
2179 esac
2180 case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
2181 m4_if(m4_index([$1],[_]),-1,[],
2182 [case $ac_cv_f77_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac
2183 ])
2184 m4_default([$2],[$1])="$ac_val"
2185 ])# AC_F77_FUNC