| # This file is part of Autoconf. -*- Autoconf -*- |
| # Programming languages support. |
| # Copyright (C) 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009 |
| # Free Software Foundation, Inc. |
| |
| # This file is part of Autoconf. This program is free |
| # software; you can redistribute it and/or modify it under the |
| # terms of the GNU General Public License as published by the |
| # Free Software Foundation, either version 3 of the License, or |
| # (at your option) any later version. |
| # |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # Under Section 7 of GPL version 3, you are granted additional |
| # permissions described in the Autoconf Configure Script Exception, |
| # version 3.0, as published by the Free Software Foundation. |
| # |
| # You should have received a copy of the GNU General Public License |
| # and a copy of the Autoconf Configure Script Exception along with |
| # this program; see the files COPYINGv3 and COPYING.EXCEPTION |
| # respectively. If not, see <http://www.gnu.org/licenses/>. |
| |
| # Written by David MacKenzie, with help from |
| # Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, |
| # Roland McGrath, Noah Friedman, david d zuhn, and many others. |
| |
| |
| # Table of Contents: |
| # |
| # 1. Language selection |
| # and routines to produce programs in a given language. |
| # |
| # 2. Producing programs in a given language. |
| # |
| # 3. Looking for a compiler |
| # And possibly the associated preprocessor. |
| # |
| # 3a. Computing EXEEXT and OBJEXT. |
| # |
| # 4. Compilers' characteristics. |
| |
| |
| |
| ## ----------------------- ## |
| ## 1. Language selection. ## |
| ## ----------------------- ## |
| |
| |
| # AC_LANG_CASE(LANG1, IF-LANG1, LANG2, IF-LANG2, ..., DEFAULT) |
| # ------------------------------------------------------------ |
| # Expand into IF-LANG1 if the current language is LANG1 etc. else |
| # into default. |
| m4_define([AC_LANG_CASE], |
| [m4_case(_AC_LANG, $@)]) |
| |
| |
| # _AC_LANG_DISPATCH(MACRO, LANG, ARGS) |
| # ------------------------------------ |
| # Call the specialization of MACRO for LANG with ARGS. Complain if |
| # unavailable. |
| m4_define([_AC_LANG_DISPATCH], |
| [m4_ifdef([$1($2)], |
| [m4_indir([$1($2)], m4_shift2($@))], |
| [m4_fatal([$1: unknown language: $2])])]) |
| |
| |
| # _AC_LANG_SET(OLD, NEW) |
| # ---------------------- |
| # Output the shell code needed to switch from OLD language to NEW language. |
| # Do not try to optimize like this: |
| # |
| # m4_defun([_AC_LANG_SET], |
| # [m4_if([$1], [$2], [], |
| # [_AC_LANG_DISPATCH([AC_LANG], [$2])])]) |
| # |
| # as it can introduce differences between the sh-current language and the |
| # m4-current-language when m4_require is used. Something more subtle |
| # might be possible, but at least for the time being, play it safe. |
| m4_defun([_AC_LANG_SET], |
| [_AC_LANG_DISPATCH([AC_LANG], [$2])]) |
| |
| |
| # AC_LANG(LANG) |
| # ------------- |
| # Set the current language to LANG. |
| m4_defun([AC_LANG], |
| [_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), |
| [$1])dnl |
| m4_define([_AC_LANG], [$1])]) |
| |
| |
| # AC_LANG_PUSH(LANG) |
| # ------------------ |
| # Save the current language, and use LANG. |
| m4_defun([AC_LANG_PUSH], |
| [_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), |
| [$1])dnl |
| m4_pushdef([_AC_LANG], [$1])]) |
| |
| |
| # AC_LANG_POP([LANG]) |
| # ------------------- |
| # If given, check that the current language is LANG, and restore the |
| # previous language. |
| m4_defun([AC_LANG_POP], |
| [m4_ifval([$1], |
| [m4_if([$1], m4_defn([_AC_LANG]), [], |
| [m4_fatal([$0($1): unexpected current language: ]m4_defn([_AC_LANG]))])])dnl |
| m4_pushdef([$0 OLD], m4_defn([_AC_LANG]))dnl |
| m4_popdef([_AC_LANG])dnl |
| _AC_LANG_SET(m4_defn([$0 OLD]), m4_defn([_AC_LANG]))dnl |
| m4_popdef([$0 OLD])dnl |
| ]) |
| |
| |
| # AC_LANG_SAVE |
| # ------------ |
| # Save the current language, but don't change language. |
| AU_DEFUN([AC_LANG_SAVE], |
| [[AC_LANG_SAVE]], |
| [Instead of using `AC_LANG', `AC_LANG_SAVE', and `AC_LANG_RESTORE', |
| you should use `AC_LANG_PUSH' and `AC_LANG_POP'.]) |
| AC_DEFUN([AC_LANG_SAVE], |
| [m4_pushdef([_AC_LANG], _AC_LANG)dnl |
| AC_DIAGNOSE([obsolete], [The macro `AC_LANG_SAVE' is obsolete. |
| You should run autoupdate.])]) |
| |
| |
| # AC_LANG_RESTORE |
| # --------------- |
| # Restore the current language from the stack. |
| AU_DEFUN([AC_LANG_RESTORE], [AC_LANG_POP($@)]) |
| |
| |
| # _AC_LANG_ABBREV |
| # --------------- |
| # Return a short signature of _AC_LANG which can be used in shell |
| # variable names, or in M4 macro names. |
| m4_defun([_AC_LANG_ABBREV], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # _AC_LANG_PREFIX |
| # --------------- |
| # Return a short (upper case) signature of _AC_LANG that is used to |
| # prefix environment variables like FLAGS. |
| m4_defun([_AC_LANG_PREFIX], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_ASSERT(LANG) |
| # -------------------- |
| # Current language must be LANG. |
| m4_defun([AC_LANG_ASSERT], |
| [m4_if(_AC_LANG, $1, [], |
| [m4_fatal([$0: current language is not $1: ] _AC_LANG)])]) |
| |
| |
| |
| # AC_LANG_DEFINE(NAME, ABBREV, PREFIX, COMPILER-VAR, COPY-FROM, SHELL-VARS) |
| # ------------------------------------------------------------------------- |
| # Define a language referenced by AC_LANG(NAME), with cache variable prefix |
| # ABBREV, Makefile variable prefix PREFIX and compiler variable COMPILER-VAR. |
| # AC_LANG(NAME) is defined to SHELL-VARS, other macros are copied from language |
| # COPY-FROM. Even if COPY-FROM is empty, a default definition is provided for |
| # language-specific macros AC_LANG_SOURCE(NAME) and AC_LANG_CONFTEST(NAME). |
| m4_define([AC_LANG_DEFINE], |
| [m4_define([AC_LANG($1)], [$6])] |
| [m4_define([_AC_LANG_ABBREV($1)], [$2])] |
| [m4_define([_AC_LANG_PREFIX($1)], [$3])] |
| [m4_define([_AC_CC($1)], [$4])] |
| [m4_copy([AC_LANG_CONFTEST($5)], [AC_LANG_CONFTEST($1)])] |
| [m4_copy([AC_LANG_SOURCE($5)], [AC_LANG_SOURCE($1)])] |
| [m4_copy([_AC_LANG_NULL_PROGRAM($5)], [_AC_LANG_NULL_PROGRAM($1)])] |
| [m4_ifval([$5], |
| [m4_copy([AC_LANG_PROGRAM($5)], [AC_LANG_PROGRAM($1)])] |
| [m4_copy([AC_LANG_CALL($5)], [AC_LANG_CALL($1)])] |
| [m4_copy([AC_LANG_FUNC_LINK_TRY($5)], [AC_LANG_FUNC_LINK_TRY($1)])] |
| [m4_copy([AC_LANG_BOOL_COMPILE_TRY($5)], [AC_LANG_BOOL_COMPILE_TRY($1)])] |
| [m4_copy([AC_LANG_INT_SAVE($5)], [AC_LANG_INT_SAVE($1)])] |
| [m4_copy([_AC_LANG_IO_PROGRAM($5)], [_AC_LANG_IO_PROGRAM($1)])])]) |
| |
| ## ----------------------- ## |
| ## 2. Producing programs. ## |
| ## ----------------------- ## |
| |
| |
| # AC_LANG_CONFTEST(BODY) |
| # ---------------------- |
| # Save the BODY in `conftest.$ac_ext'. Add a trailing new line. |
| AC_DEFUN([AC_LANG_CONFTEST], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_CONFTEST()(BODY) |
| # ------------------------ |
| # Default implementation of AC_LANG_CONFTEST. |
| m4_define([AC_LANG_CONFTEST()], |
| [cat > conftest.$ac_ext <<_ACEOF |
| $1 |
| _ACEOF]) |
| |
| |
| # AC_LANG_SOURCE(BODY) |
| # -------------------- |
| # Produce a valid source for the current language, which includes the |
| # BODY, and as much as possible `confdefs.h'. |
| AC_DEFUN([AC_LANG_SOURCE], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_SOURCE()(BODY) |
| # ---------------------- |
| # Default implementation of AC_LANG_SOURCE. |
| m4_define([AC_LANG_SOURCE()], |
| [$1]) |
| |
| |
| # AC_LANG_PROGRAM([PROLOGUE], [BODY]) |
| # ----------------------------------- |
| # Produce a valid source for the current language. Prepend the |
| # PROLOGUE (typically CPP directives and/or declarations) to an |
| # execution the BODY (typically glued inside the `main' function, or |
| # equivalent). |
| AC_DEFUN([AC_LANG_PROGRAM], |
| [AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) |
| |
| |
| # _AC_LANG_NULL_PROGRAM()() |
| # ------------------------- |
| # Default implementation of AC_LANG_NULL_PROGRAM |
| m4_define([_AC_LANG_NULL_PROGRAM()], |
| [AC_LANG_PROGRAM([], [])]) |
| |
| |
| # _AC_LANG_NULL_PROGRAM |
| # ---------------------- |
| # Produce valid source for the current language that does |
| # nothing. |
| AC_DEFUN([_AC_LANG_NULL_PROGRAM], |
| [AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) |
| |
| |
| # _AC_LANG_IO_PROGRAM |
| # ----------------------------------- |
| # Produce valid source for the current language that creates |
| # a file. (This is used when detecting whether executables |
| # work, e.g. to detect cross-compiling.) |
| AC_DEFUN([_AC_LANG_IO_PROGRAM], |
| [AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) |
| |
| |
| # AC_LANG_CALL(PROLOGUE, FUNCTION) |
| # -------------------------------- |
| # Call the FUNCTION. |
| AC_DEFUN([AC_LANG_CALL], |
| [m4_ifval([$2], [], [m4_warn([syntax], [$0: no function given])])dnl |
| _AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_FUNC_LINK_TRY(FUNCTION) |
| # ------------------------------- |
| # Produce a source which links correctly iff the FUNCTION exists. |
| AC_DEFUN([AC_LANG_FUNC_LINK_TRY], |
| [m4_ifval([$1], [], [m4_warn([syntax], [$0: no function given])])dnl |
| _AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_BOOL_COMPILE_TRY(PROLOGUE, EXPRESSION) |
| # ---------------------------------------------- |
| # Produce a program that compiles with success iff the boolean EXPRESSION |
| # evaluates to true at compile time. |
| AC_DEFUN([AC_LANG_BOOL_COMPILE_TRY], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_INT_SAVE(PROLOGUE, EXPRESSION) |
| # -------------------------------------- |
| # Produce a program that saves the runtime evaluation of the integer |
| # EXPRESSION into `conftest.val'. |
| AC_DEFUN([AC_LANG_INT_SAVE], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # _AC_CC |
| # ------ |
| # The variable name of the compiler. |
| m4_define([_AC_CC], |
| [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| ## -------------------------------------------- ## |
| ## 3. Looking for Compilers and Preprocessors. ## |
| ## -------------------------------------------- ## |
| |
| |
| # AC_LANG_COMPILER |
| # ---------------- |
| # Find a compiler for the current LANG. Be sure to be run before |
| # AC_LANG_PREPROC. |
| # |
| # Note that because we might AC_REQUIRE `AC_LANG_COMPILER(C)' for |
| # instance, the latter must be AC_DEFUN'd, not just define'd. |
| m4_define([AC_LANG_COMPILER], |
| [AC_BEFORE([AC_LANG_COMPILER(]_AC_LANG[)], |
| [AC_LANG_PREPROC(]_AC_LANG[)])dnl |
| _AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_COMPILER_REQUIRE |
| # ------------------------ |
| # Ensure we have a compiler for the current LANG. |
| AC_DEFUN([AC_LANG_COMPILER_REQUIRE], |
| [m4_require([AC_LANG_COMPILER(]_AC_LANG[)], |
| [AC_LANG_COMPILER])]) |
| |
| |
| |
| # _AC_LANG_COMPILER_GNU |
| # --------------------- |
| # Check whether the compiler for the current language is GNU. |
| # |
| # It doesn't seem necessary right now to have a different source |
| # according to the current language, since this works fine. Some day |
| # it might be needed. Nevertheless, pay attention to the fact that |
| # the position of `choke me' on the seventh column is meant: otherwise |
| # some Fortran compilers (e.g., SGI) might consider it's a |
| # continuation line, and warn instead of reporting an error. |
| m4_define([_AC_LANG_COMPILER_GNU], |
| [AC_CACHE_CHECK([whether we are using the GNU _AC_LANG compiler], |
| [ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu], |
| [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[#ifndef __GNUC__ |
| choke me |
| #endif |
| ]])], |
| [ac_compiler_gnu=yes], |
| [ac_compiler_gnu=no]) |
| ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu=$ac_compiler_gnu |
| ])])# _AC_LANG_COMPILER_GNU |
| |
| |
| # AC_LANG_PREPROC |
| # --------------- |
| # Find a preprocessor for the current language. Note that because we |
| # might AC_REQUIRE `AC_LANG_PREPROC(C)' for instance, the latter must |
| # be AC_DEFUN'd, not just define'd. Since the preprocessor depends |
| # upon the compiler, look for the compiler. |
| m4_define([AC_LANG_PREPROC], |
| [AC_LANG_COMPILER_REQUIRE()dnl |
| _AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) |
| |
| |
| # AC_LANG_PREPROC_REQUIRE |
| # ----------------------- |
| # Ensure we have a preprocessor for the current language. |
| AC_DEFUN([AC_LANG_PREPROC_REQUIRE], |
| [m4_require([AC_LANG_PREPROC(]_AC_LANG[)], |
| [AC_LANG_PREPROC])]) |
| |
| |
| # AC_REQUIRE_CPP |
| # -------------- |
| # Require the preprocessor for the current language. |
| # FIXME: AU_ALIAS once AC_LANG is officially documented (2.51?). |
| AC_DEFUN([AC_REQUIRE_CPP], |
| [AC_LANG_PREPROC_REQUIRE]) |
| |
| |
| |
| # AC_NO_EXECUTABLES |
| # ----------------- |
| # FIXME: The GCC team has specific needs which the current Autoconf |
| # framework cannot solve elegantly. This macro implements a dirty |
| # hack until Autoconf is able to provide the services its users |
| # need. |
| # |
| # Several of the support libraries that are often built with GCC can't |
| # assume the tool-chain is already capable of linking a program: the |
| # compiler often expects to be able to link with some of such |
| # libraries. |
| # |
| # In several of these libraries, workarounds have been introduced to |
| # avoid the AC_PROG_CC_WORKS test, that would just abort their |
| # configuration. The introduction of AC_EXEEXT, enabled either by |
| # libtool or by CVS autoconf, have just made matters worse. |
| # |
| # Unlike an earlier version of this macro, using AC_NO_EXECUTABLES does |
| # not disable link tests at autoconf time, but at configure time. |
| # This allows AC_NO_EXECUTABLES to be invoked conditionally. |
| AC_DEFUN_ONCE([AC_NO_EXECUTABLES], |
| [m4_divert_push([KILL]) |
| m4_divert_text([DEFAULTS], [ac_no_link=no]) |
| |
| AC_BEFORE([$0], [_AC_COMPILER_EXEEXT]) |
| AC_BEFORE([$0], [AC_LINK_IFELSE]) |
| |
| m4_define([_AC_COMPILER_EXEEXT], |
| [AC_LANG_CONFTEST([_AC_LANG_NULL_PROGRAM]) |
| if _AC_DO_VAR(ac_link); then |
| ac_no_link=no |
| ]m4_defn([_AC_COMPILER_EXEEXT])[ |
| else |
| rm -f -r a.out a.exe b.out conftest.$ac_ext conftest.o conftest.obj conftest.dSYM |
| ac_no_link=yes |
| # Setting cross_compile will disable run tests; it will |
| # also disable AC_CHECK_FILE but that's generally |
| # correct if we can't link. |
| cross_compiling=yes |
| EXEEXT= |
| _AC_COMPILER_EXEEXT_CROSS |
| fi |
| ]) |
| |
| m4_define([AC_LINK_IFELSE], |
| [if test x$ac_no_link = xyes; then |
| AC_MSG_ERROR([link tests are not allowed after AC@&t@_NO_EXECUTABLES]) |
| fi |
| ]m4_defn([AC_LINK_IFELSE])) |
| |
| m4_divert_pop()dnl |
| ])# AC_NO_EXECUTABLES |
| |
| |
| |
| # --------------------------------- # |
| # 3a. Computing EXEEXT and OBJEXT. # |
| # --------------------------------- # |
| |
| |
| # Files to ignore |
| # --------------- |
| # Ignore .d files produced by CFLAGS=-MD. |
| # |
| # On UWIN (which uses a cc wrapper for MSVC), the compiler also generates |
| # a .pdb file |
| # |
| # When the w32 free Borland C++ command line compiler links a program |
| # (conftest.exe), it also produces a file named `conftest.tds' in |
| # addition to `conftest.obj'. |
| # |
| # - *.bb, *.bbg |
| # Created per object by GCC when given -ftest-coverage. |
| # |
| # - *.xSYM |
| # Created on BeOS. Seems to be per executable. |
| # |
| # - *.map, *.inf |
| # Created by the Green Hills compiler. |
| # |
| # - *.dSYM |
| # Directory created on Mac OS X Leopard. |
| |
| |
| # _AC_COMPILER_OBJEXT_REJECT |
| # -------------------------- |
| # Case/esac pattern matching the files to be ignored when looking for |
| # compiled object files. |
| m4_define([_AC_COMPILER_OBJEXT_REJECT], |
| [*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM]) |
| |
| |
| # _AC_COMPILER_EXEEXT_REJECT |
| # -------------------------- |
| # Case/esac pattern matching the files to be ignored when looking for |
| # compiled executables. |
| m4_define([_AC_COMPILER_EXEEXT_REJECT], |
| [_AC_COMPILER_OBJEXT_REJECT | *.o | *.obj]) |
| |
| |
| # We must not AU define them, because autoupdate would then remove |
| # them, which is right, but Automake 1.4 would remove the support for |
| # $(EXEEXT) etc. |
| # FIXME: Remove this once Automake fixed. |
| AC_DEFUN([AC_EXEEXT], []) |
| AC_DEFUN([AC_OBJEXT], []) |
| |
| |
| # _AC_COMPILER_EXEEXT_DEFAULT |
| # --------------------------- |
| # Check for the extension used for the default name for executables. |
| # |
| # We do this in order to find out what is the extension we must add for |
| # creating executables (see _AC_COMPILER_EXEEXT's comments). |
| # |
| # On OpenVMS 7.1 system, the DEC C 5.5 compiler when called through a |
| # GNV (gnv.sourceforge.net) cc wrapper, produces the output file named |
| # `a_out.exe'. |
| # b.out is created by i960 compilers. |
| # |
| # Start with the most likely output file names, but: |
| # 1) Beware the clever `test -f' on Cygwin, try the DOS-like .exe names |
| # before the counterparts without the extension. |
| # 2) The algorithm is not robust to junk in `.', hence go to wildcards |
| # (conftest.*) only as a last resort. |
| # Beware of `expr' that may return `0' or `'. Since this macro is |
| # the first one in touch with the compiler, it should also check that |
| # it compiles properly. |
| # |
| # The IRIX 6 linker writes into existing files which may not be |
| # executable, retaining their permissions. Remove them first so a |
| # subsequent execution test works. |
| # |
| m4_define([_AC_COMPILER_EXEEXT_DEFAULT], |
| [# Try to create an executable without -o first, disregard a.out. |
| # It will help us diagnose broken compilers, and finding out an intuition |
| # of exeext. |
| AC_MSG_CHECKING([whether the _AC_LANG compiler works]) |
| ac_link_default=`AS_ECHO(["$ac_link"]) | sed ['s/ -o *conftest[^ ]*//']` |
| |
| # The possible output files: |
| ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" |
| |
| ac_rmfiles= |
| for ac_file in $ac_files |
| do |
| case $ac_file in |
| _AC_COMPILER_EXEEXT_REJECT ) ;; |
| * ) ac_rmfiles="$ac_rmfiles $ac_file";; |
| esac |
| done |
| rm -f $ac_rmfiles |
| |
| AS_IF([_AC_DO_VAR(ac_link_default)], |
| [# Autoconf-2.13 could set the ac_cv_exeext variable to `no'. |
| # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' |
| # in a Makefile. We should not override ac_cv_exeext if it was cached, |
| # so that the user can short-circuit this test for compilers unknown to |
| # Autoconf. |
| for ac_file in $ac_files '' |
| do |
| test -f "$ac_file" || continue |
| case $ac_file in |
| _AC_COMPILER_EXEEXT_REJECT ) |
| ;; |
| [[ab]].out ) |
| # We found the default executable, but exeext='' is most |
| # certainly right. |
| break;; |
| *.* ) |
| if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; |
| then :; else |
| ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` |
| fi |
| # We set ac_cv_exeext here because the later test for it is not |
| # safe: cross compilers may not add the suffix if given an `-o' |
| # argument, so we may need to know it at that point already. |
| # Even if this section looks crufty: it has the advantage of |
| # actually working. |
| break;; |
| * ) |
| break;; |
| esac |
| done |
| test "$ac_cv_exeext" = no && ac_cv_exeext= |
| ], |
| [ac_file='']) |
| AS_IF([test -z "$ac_file"], |
| [AC_MSG_RESULT([no]) |
| _AC_MSG_LOG_CONFTEST |
| AC_MSG_FAILURE([_AC_LANG compiler cannot create executables], 77)], |
| [AC_MSG_RESULT([yes])]) |
| AC_MSG_CHECKING([for _AC_LANG compiler default output file name]) |
| AC_MSG_RESULT([$ac_file]) |
| ac_exeext=$ac_cv_exeext |
| ])# _AC_COMPILER_EXEEXT_DEFAULT |
| |
| |
| # _AC_COMPILER_EXEEXT_CROSS |
| # ------------------------- |
| # FIXME: These cross compiler hacks should be removed for Autoconf 3.0 |
| # |
| # It is not sufficient to run a no-op program -- this succeeds and gives |
| # a false negative when cross-compiling for the compute nodes on the |
| # IBM Blue Gene/L. Instead, _AC_COMPILER_EXEEXT calls _AC_LANG_IO_PROGRAM |
| # to create a program that writes to a file, which is sufficient to |
| # detect cross-compiling on Blue Gene. Note also that AC_COMPUTE_INT |
| # requires programs that create files when not cross-compiling, so it |
| # is safe and not a bad idea to check for this capability in general. |
| m4_define([_AC_COMPILER_EXEEXT_CROSS], |
| [# Check that the compiler produces executables we can run. If not, either |
| # the compiler is broken, or we cross compile. |
| AC_MSG_CHECKING([whether we are cross compiling]) |
| if test "$cross_compiling" != yes; then |
| _AC_DO_VAR(ac_link) |
| if _AC_DO_TOKENS([./conftest$ac_cv_exeext]); then |
| cross_compiling=no |
| else |
| if test "$cross_compiling" = maybe; then |
| cross_compiling=yes |
| else |
| AC_MSG_FAILURE([cannot run _AC_LANG compiled programs. |
| If you meant to cross compile, use `--host'.]) |
| fi |
| fi |
| fi |
| AC_MSG_RESULT([$cross_compiling]) |
| ])# _AC_COMPILER_EXEEXT_CROSS |
| |
| |
| # _AC_COMPILER_EXEEXT_O |
| # --------------------- |
| # Check for the extension used when `-o foo'. Try to see if ac_cv_exeext, |
| # as computed by _AC_COMPILER_EXEEXT_DEFAULT is OK. |
| m4_define([_AC_COMPILER_EXEEXT_O], |
| [AC_MSG_CHECKING([for suffix of executables]) |
| AS_IF([_AC_DO_VAR(ac_link)], |
| [# If both `conftest.exe' and `conftest' are `present' (well, observable) |
| # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will |
| # work properly (i.e., refer to `conftest.exe'), while it won't with |
| # `rm'. |
| for ac_file in conftest.exe conftest conftest.*; do |
| test -f "$ac_file" || continue |
| case $ac_file in |
| _AC_COMPILER_EXEEXT_REJECT ) ;; |
| *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` |
| break;; |
| * ) break;; |
| esac |
| done], |
| [AC_MSG_FAILURE([cannot compute suffix of executables: cannot compile and link])]) |
| rm -f conftest conftest$ac_cv_exeext |
| AC_MSG_RESULT([$ac_cv_exeext]) |
| ])# _AC_COMPILER_EXEEXT_O |
| |
| |
| # _AC_COMPILER_EXEEXT |
| # ------------------- |
| # Check for the extension used for executables. It compiles a test |
| # executable. If this is called, the executable extensions will be |
| # automatically used by link commands run by the configure script. |
| # |
| # Note that some compilers (cross or not), strictly obey to `-o foo' while |
| # the host requires `foo.exe', so we should not depend upon `-o' to |
| # test EXEEXT. But then, be sure not to destroy user files. |
| # |
| # Must be run before _AC_COMPILER_OBJEXT because _AC_COMPILER_EXEEXT_DEFAULT |
| # checks whether the compiler works. |
| # |
| # Do not rename this macro; Automake decides whether EXEEXT is used |
| # by checking whether `_AC_COMPILER_EXEEXT' has been expanded. |
| # |
| # See _AC_COMPILER_EXEEXT_CROSS for why we need _AC_LANG_IO_PROGRAM. |
| m4_define([_AC_COMPILER_EXEEXT], |
| [AC_LANG_CONFTEST([_AC_LANG_NULL_PROGRAM]) |
| ac_clean_files_save=$ac_clean_files |
| ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" |
| _AC_COMPILER_EXEEXT_DEFAULT |
| rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out |
| ac_clean_files=$ac_clean_files_save |
| _AC_COMPILER_EXEEXT_O |
| rm -f conftest.$ac_ext |
| AC_SUBST([EXEEXT], [$ac_cv_exeext])dnl |
| ac_exeext=$EXEEXT |
| AC_LANG_CONFTEST([_AC_LANG_IO_PROGRAM]) |
| ac_clean_files="$ac_clean_files conftest.out" |
| _AC_COMPILER_EXEEXT_CROSS |
| rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out |
| ac_clean_files=$ac_clean_files_save |
| ])# _AC_COMPILER_EXEEXT |
| |
| |
| # _AC_COMPILER_OBJEXT |
| # ------------------- |
| # Check the object extension used by the compiler: typically `.o' or |
| # `.obj'. If this is called, some other behavior will change, |
| # determined by ac_objext. |
| # |
| # This macro is called by AC_LANG_COMPILER, the latter being required |
| # by the AC_COMPILE_IFELSE macros, so use _AC_COMPILE_IFELSE. And in fact, |
| # don't, since _AC_COMPILE_IFELSE needs to know ac_objext for the `test -s' |
| # it includes. So do it by hand. |
| m4_define([_AC_COMPILER_OBJEXT], |
| [AC_CACHE_CHECK([for suffix of object files], ac_cv_objext, |
| [AC_LANG_CONFTEST([_AC_LANG_NULL_PROGRAM]) |
| rm -f conftest.o conftest.obj |
| AS_IF([_AC_DO_VAR(ac_compile)], |
| [for ac_file in conftest.o conftest.obj conftest.*; do |
| test -f "$ac_file" || continue; |
| case $ac_file in |
| _AC_COMPILER_OBJEXT_REJECT ) ;; |
| *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` |
| break;; |
| esac |
| done], |
| [_AC_MSG_LOG_CONFTEST |
| AC_MSG_FAILURE([cannot compute suffix of object files: cannot compile])]) |
| rm -f conftest.$ac_cv_objext conftest.$ac_ext]) |
| AC_SUBST([OBJEXT], [$ac_cv_objext])dnl |
| ac_objext=$OBJEXT |
| ])# _AC_COMPILER_OBJEXT |
| |
| |
| |
| |
| ## ------------------------------- ## |
| ## 4. Compilers' characteristics. ## |
| ## ------------------------------- ## |
| |
| # AC_LANG_WERROR |
| # ------------------ |
| # Treat warnings from the current language's preprocessor, compiler, and |
| # linker as fatal errors. |
| AC_DEFUN([AC_LANG_WERROR], |
| [m4_divert_text([DEFAULTS], [ac_[]_AC_LANG_ABBREV[]_werror_flag=]) |
| ac_[]_AC_LANG_ABBREV[]_werror_flag=yes])# AC_LANG_WERROR |