mirror of
git://git.sv.gnu.org/autoconf
synced 2025-01-18 10:45:15 +08:00
7e4f776a09
Autoconf's file, do it afterwards, so that Autoconf promotes the right use, but users still can use the old names. Of course this revealed numerous non updated uses of old macros in Autoconf's files. Adjust them. But for the time being, keep `define' alive for Autoconf.
1747 lines
50 KiB
Plaintext
1747 lines
50 KiB
Plaintext
# This file is part of Autoconf. -*- Autoconf -*-
|
|
# Programming languages support.
|
|
# Copyright 1992, 93, 94, 95, 96, 98, 99, 2000
|
|
# Free Software Foundation, Inc.
|
|
#
|
|
# 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 2, 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.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
# 02111-1307, USA.
|
|
#
|
|
# As a special exception, the Free Software Foundation gives unlimited
|
|
# permission to copy, distribute and modify the configure scripts that
|
|
# are the output of Autoconf. You need not follow the terms of the GNU
|
|
# General Public License when using or distributing such scripts, even
|
|
# though portions of the text of Autoconf appear in them. The GNU
|
|
# General Public License (GPL) does govern all other use of the material
|
|
# that constitutes the Autoconf program.
|
|
#
|
|
# Certain portions of the Autoconf source text are designed to be copied
|
|
# (in certain cases, depending on the input) into the output of
|
|
# Autoconf. We call these the "data" portions. The rest of the Autoconf
|
|
# source text consists of comments plus executable code that decides which
|
|
# of the data portions to output in any given case. We call these
|
|
# comments and executable code the "non-data" portions. Autoconf never
|
|
# copies any of the non-data portions into its output.
|
|
#
|
|
# This special exception to the GPL applies to versions of Autoconf
|
|
# released by the Free Software Foundation. When you make and
|
|
# distribute a modified version of Autoconf, you may extend this special
|
|
# exception to the GPL to apply to your modified version as well, *unless*
|
|
# your modified version has the potential to copy into its output some
|
|
# of the text that was the non-data portion of the version that you started
|
|
# with. (In other words, unless your change moves or copies text from
|
|
# the non-data portions to the data portions.) If your modification has
|
|
# such potential, you must delete any notice of this special exception
|
|
# to the GPL from your modified version.
|
|
#
|
|
# 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.
|
|
# a. generic routines
|
|
# b. C
|
|
# c. C++
|
|
# d. Fortran 77
|
|
#
|
|
# 2. Producing programs in a given language.
|
|
# a. generic routines
|
|
# b. C
|
|
# c. C++
|
|
# d. Fortran 77
|
|
#
|
|
# 3. Looking for a compiler
|
|
# And possibly the associated preprocessor.
|
|
# a. Generic routines.
|
|
# b. C
|
|
# c. C++
|
|
# d. Fortran 77
|
|
#
|
|
# 4. Compilers' characteristics.
|
|
# a. Generic routines.
|
|
# b. C
|
|
# c. C++
|
|
# d. Fortran 77
|
|
|
|
|
|
|
|
## ----------------------- ##
|
|
## 1. Language selection. ##
|
|
## ----------------------- ##
|
|
|
|
|
|
|
|
# -------------------------------- #
|
|
# 1a. Generic 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.
|
|
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.
|
|
define([_AC_LANG_DISPATCH],
|
|
[ifdef([$1($2)],
|
|
[m4_indir([$1($2)], m4_shiftn(2, $@))],
|
|
[AC_FATAL([$1: unknown language: $2])])])
|
|
|
|
|
|
# AC_LANG(LANG)
|
|
# -------------
|
|
# Set the current language to LANG.
|
|
#
|
|
# Do *not* write AC_LANG([$1]), because this pair of parens does not
|
|
# correspond to an evaluation, rather, they are just part of the name.
|
|
# If you add quotes here, they will be part of the name too, yielding
|
|
# `AC_LANG([C])' for instance, which does not exist.
|
|
AC_DEFUN([AC_LANG],
|
|
[define([_AC_LANG], [$1])dnl
|
|
_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
|
|
|
|
|
|
# AC_LANG_PUSH(LANG)
|
|
# ------------------
|
|
# Save the current language, and use LANG.
|
|
define([AC_LANG_PUSH],
|
|
[m4_pushdef([_AC_LANG])dnl
|
|
AC_LANG([$1])])
|
|
|
|
|
|
# AC_LANG_POP
|
|
# -----------
|
|
# Restore the previous language.
|
|
define([AC_LANG_POP],
|
|
[m4_popdef([_AC_LANG])dnl
|
|
ifelse(_AC_LANG, [_AC_LANG],
|
|
[AC_FATAL([too many $0])])dnl
|
|
AC_LANG(_AC_LANG)])
|
|
|
|
|
|
# AC_LANG_SAVE
|
|
# ------------
|
|
# Save the current language, but don't change language.
|
|
AU_DEFUN([AC_LANG_SAVE],
|
|
[AC_DIAGNOSE([obsolete],
|
|
[instead of using `AC_LANG', `AC_LANG_SAVE',
|
|
and `AC_LANG_RESTORE', you should use `AC_LANG_PUSH' and `AC_LANG_POP'.])
|
|
m4_pushdef([_AC_LANG], _AC_LANG)])
|
|
|
|
|
|
# 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.
|
|
define([_AC_LANG_ABBREV],
|
|
[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
|
|
|
|
|
|
# -------------------- #
|
|
# 1b. The C language. #
|
|
# -------------------- #
|
|
|
|
|
|
# AC_LANG(C)
|
|
# ----------
|
|
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
|
|
define([AC_LANG(C)],
|
|
[ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AC_FD_LOG'
|
|
ac_link='${CC-cc} -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AC_FD_LOG'
|
|
ac_compiler_gnu=$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu
|
|
])
|
|
|
|
|
|
# AC_LANG_C
|
|
# ---------
|
|
AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
|
|
|
|
|
|
# _AC_LANG_ABBREV(C)
|
|
# ------------------
|
|
define([_AC_LANG_ABBREV(C)], [c])
|
|
|
|
|
|
# ---------------------- #
|
|
# 1c. The C++ language. #
|
|
# ---------------------- #
|
|
|
|
|
|
# AC_LANG(C++)
|
|
# ------------
|
|
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
|
|
define([AC_LANG(C++)],
|
|
[ac_ext=cc
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AC_FD_LOG'
|
|
ac_link='${CXX-g++} -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AC_FD_LOG'
|
|
ac_compiler_gnu=$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu
|
|
])
|
|
|
|
|
|
# AC_LANG_CPLUSPLUS
|
|
# -----------------
|
|
AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)])
|
|
|
|
|
|
# _AC_LANG_ABBREV(C++)
|
|
# --------------------
|
|
define([_AC_LANG_ABBREV(C++)], [cxx])
|
|
|
|
|
|
# ----------------------------- #
|
|
# 1d. The Fortran 77 language. #
|
|
# ----------------------------- #
|
|
|
|
|
|
# AC_LANG(Fortran 77)
|
|
# -------------------
|
|
define([AC_LANG(Fortran 77)],
|
|
[ac_ext=f
|
|
ac_compile='${F77-f77} -c $FFLAGS conftest.$ac_ext >&AC_FD_LOG'
|
|
ac_link='${F77-f77} -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AC_FD_LOG'
|
|
ac_compiler_gnu=$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu
|
|
])
|
|
|
|
|
|
# AC_LANG_FORTRAN77
|
|
# -----------------
|
|
AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)])
|
|
|
|
|
|
# _AC_LANG_ABBREV(Fortran 77)
|
|
# ---------------------------
|
|
define([_AC_LANG_ABBREV(Fortran 77)], [f77])
|
|
|
|
|
|
|
|
## ---------------------- ##
|
|
## 2.Producing programs. ##
|
|
## ---------------------- ##
|
|
|
|
|
|
# ---------------------- #
|
|
# 2a. Generic routines. #
|
|
# ---------------------- #
|
|
|
|
|
|
# AC_LANG_CONFTEST(BODY)
|
|
# ----------------------
|
|
# Save the BODY in `conftest.$ac_ext'. Add a trailing new line.
|
|
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' and the `#line' sync
|
|
# lines.
|
|
AC_DEFUN([AC_LANG_SOURCE],
|
|
[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
|
|
|
|
|
|
# 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_CALL(PROLOGUE, FUNCTION)
|
|
# --------------------------------
|
|
# Call the FUNCTION.
|
|
AC_DEFUN([AC_LANG_CALL],
|
|
[_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],
|
|
[_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 `conftestval'.
|
|
AC_DEFUN([AC_LANG_INT_SAVE],
|
|
[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
|
|
|
|
|
|
# --------------- #
|
|
# 2b. C sources. #
|
|
# --------------- #
|
|
|
|
# AC_LANG_SOURCE(C)(BODY)
|
|
# -----------------------
|
|
# This sometimes fails to find confdefs.h, for some reason.
|
|
# #line __oline__ "$[0]"
|
|
define([AC_LANG_SOURCE(C)],
|
|
[#line __oline__ "configure"
|
|
#include "confdefs.h"
|
|
$1])
|
|
|
|
|
|
# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY])
|
|
# --------------------------------------
|
|
define([AC_LANG_PROGRAM(C)],
|
|
[$1
|
|
int
|
|
main ()
|
|
{
|
|
dnl Do *not* indent the following line: there may be CPP directives.
|
|
dnl Don't move the `;' right after for the same reason.
|
|
$2
|
|
;
|
|
return 0;
|
|
}])
|
|
|
|
|
|
# AC_LANG_CALL(C)(PROLOGUE, FUNCTION)
|
|
# -----------------------------------
|
|
# Avoid conflicting decl of main.
|
|
define([AC_LANG_CALL(C)],
|
|
[AC_LANG_PROGRAM([$1
|
|
ifelse([$2], [main], ,
|
|
[/* Override any gcc2 internal prototype to avoid an error. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
/* We use char because int might match the return type of a gcc2
|
|
builtin and then its argument prototype would still apply. */
|
|
char $2 ();])], [$2 ();])])
|
|
|
|
|
|
# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION)
|
|
# ----------------------------------
|
|
# Don't include <ctype.h> because on OSF/1 3.0 it includes
|
|
# <sys/types.h> which includes <sys/select.h> which contains a
|
|
# prototype for select. Similarly for bzero.
|
|
define([AC_LANG_FUNC_LINK_TRY(C)],
|
|
[AC_LANG_PROGRAM(
|
|
[/* System header to define __stub macros and hopefully few prototypes,
|
|
which can conflict with char $1 (); below. */
|
|
#include <assert.h>
|
|
/* Override any gcc2 internal prototype to avoid an error. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
/* We use char because int might match the return type of a gcc2
|
|
builtin and then its argument prototype would still apply. */
|
|
char $1 ();
|
|
char (*f) ();
|
|
],
|
|
[/* The GNU C library defines this for functions which it implements
|
|
to always fail with ENOSYS. Some functions are actually named
|
|
something starting with __ and the normal name is an alias. */
|
|
#if defined (__stub_$1) || defined (__stub___$1)
|
|
choke me
|
|
#else
|
|
f = $1;
|
|
#endif
|
|
])])
|
|
|
|
|
|
# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION)
|
|
# -------------------------------------------------
|
|
define([AC_LANG_BOOL_COMPILE_TRY(C)],
|
|
[AC_LANG_PROGRAM([$1], [int _array_ @<:@1 - 2 * !($2)@:>@])])
|
|
|
|
|
|
# AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION)
|
|
# -----------------------------------------
|
|
# We need `stdio.h' to open a `FILE', so the prologue defaults to the
|
|
# inclusion of `stdio.h'.
|
|
define([AC_LANG_INT_SAVE(C)],
|
|
[AC_LANG_PROGRAM([m4_default([$1], [@%:@include "stdio.h"])],
|
|
[FILE *f = fopen ("conftestval", "w");
|
|
if (!f)
|
|
exit (1);
|
|
fprintf (f, "%d\n", ($2));])])
|
|
|
|
|
|
# ----------------- #
|
|
# 2c. C++ sources. #
|
|
# ----------------- #
|
|
|
|
# AC_LANG_SOURCE(C++)(BODY)
|
|
# -------------------------
|
|
define([AC_LANG_SOURCE(C++)],
|
|
[#line __oline__ "configure"
|
|
#include "confdefs.h"
|
|
#ifdef __cplusplus
|
|
extern "C" void exit (int);
|
|
#endif
|
|
$1])
|
|
|
|
|
|
# AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
|
|
# ----------------------------------------
|
|
# Same as C.
|
|
define([AC_LANG_PROGRAM(C++)], m4_defn([AC_LANG_PROGRAM(C)]))
|
|
|
|
|
|
# AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
|
|
# -------------------------------------
|
|
# Same as C.
|
|
define([AC_LANG_CALL(C++)], m4_defn([AC_LANG_CALL(C)]))
|
|
|
|
|
|
# AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
|
|
# ------------------------------------
|
|
# Same as C.
|
|
define([AC_LANG_FUNC_LINK_TRY(C++)], m4_defn([AC_LANG_FUNC_LINK_TRY(C)]))
|
|
|
|
|
|
# AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION)
|
|
# ---------------------------------------------------
|
|
# Same as C.
|
|
define([AC_LANG_BOOL_COMPILE_TRY(C++)], m4_defn([AC_LANG_BOOL_COMPILE_TRY(C)]))
|
|
|
|
|
|
# AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
|
|
# -------------------------------------------
|
|
# Same as C.
|
|
define([AC_LANG_INT_SAVE(C++)], m4_defn([AC_LANG_INT_SAVE(C)]))
|
|
|
|
|
|
|
|
# ------------------------ #
|
|
# 2d. Fortran 77 sources. #
|
|
# ------------------------ #
|
|
|
|
# AC_LANG_SOURCE(Fortran 77)(BODY)
|
|
# --------------------------------
|
|
# FIXME: Apparently, according to former AC_TRY_COMPILER, the CPP
|
|
# directives must not be included. But AC_TRY_RUN_NATIVE was not
|
|
# avoiding them, so?
|
|
define([AC_LANG_SOURCE(Fortran 77)],
|
|
[$1])
|
|
|
|
|
|
# AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY])
|
|
# -----------------------------------------------
|
|
# Yes, we discard the PROLOGUE.
|
|
define([AC_LANG_PROGRAM(Fortran 77)],
|
|
[ program main
|
|
$2
|
|
end])
|
|
|
|
|
|
# AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION)
|
|
# --------------------------------------------
|
|
# FIXME: This is a guess, help!
|
|
define([AC_LANG_CALL(Fortran 77)],
|
|
[AC_LANG_PROGRAM([$1],
|
|
[ call $2])])
|
|
|
|
|
|
|
|
|
|
## -------------------------------------------- ##
|
|
## 3. Looking for Compilers and Preprocessors. ##
|
|
## -------------------------------------------- ##
|
|
|
|
# ----------------------------------------------------- #
|
|
# 3a. Generic routines in compilers and preprocessors. #
|
|
# ----------------------------------------------------- #
|
|
|
|
# AC_LANG_COMPILER
|
|
# ----------------
|
|
# Find a compiler for the current LANG. Note that because we might
|
|
# AC_REQUIRE `AC_LANG_COMPILER(C)' for instance, the latter must be
|
|
# AC_DEFUN'd, not just define'd.
|
|
define([AC_LANG_COMPILER],
|
|
[_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],
|
|
[_AC_REQUIRE([AC_LANG_COMPILER(]_AC_LANG[)],
|
|
[m4_indir([AC_LANG_COMPILER(]_AC_LANG[)])])])
|
|
|
|
|
|
# AC_REQUIRE_CPP
|
|
# --------------
|
|
# Require finding the C or C++ preprocessor, whichever is the
|
|
# current language.
|
|
AC_DEFUN([AC_REQUIRE_CPP],
|
|
[AC_LANG_CASE(C, [AC_REQUIRE([AC_PROG_CPP])],
|
|
C++, [AC_REQUIRE([AC_PROG_CXXCPP])],
|
|
[AC_FATAL([No preprocessor defined for ]_AC_LANG)])])
|
|
|
|
|
|
# _AC_LANG_COMPILER_WORKS
|
|
# -----------------------
|
|
define([_AC_LANG_COMPILER_WORKS],
|
|
[AC_MSG_CHECKING([whether the _AC_LANG compiler works])
|
|
_AC_LINK_IFELSE([AC_LANG_PROGRAM()],
|
|
[# FIXME: these cross compiler hacks should be removed for autoconf 3.0
|
|
# If not cross compiling, check that we can run a simple program.
|
|
if test "$cross_compiling" != yes; then
|
|
if AC_TRY_COMMAND(./conftest$ac_exeext); then
|
|
cross_compiling=no
|
|
else
|
|
if test "$cross_compiling" = maybe; then
|
|
cross_compiling=yes
|
|
else
|
|
AC_MSG_ERROR([cannot run _AC_LANG compiled programs.
|
|
To enable cross compilation, use `--host'.])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT(yes)],
|
|
[AC_MSG_RESULT(no)
|
|
AC_MSG_ERROR([_AC_LANG compiler cannot create executables], 77)])
|
|
AC_MSG_CHECKING([whether we are cross compiling])
|
|
AC_MSG_RESULT($cross_compiling)
|
|
])# _AC_LANG_COMPILER_WORKS
|
|
|
|
|
|
# _AC_LANG_COMPILER_GNU
|
|
# ---------------------
|
|
# Check whether the compiler for the current language is GNU.
|
|
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_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 abble to provide the services its users
|
|
# needs.
|
|
#
|
|
# 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, work-arounds 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.
|
|
AC_DEFUN_ONCE([AC_NO_EXECUTABLES],
|
|
[m4_divert_push([KILL])
|
|
|
|
AC_BEFORE([$0], [_AC_LANG_COMPILER_WORKS])
|
|
AC_BEFORE([$0], [_AC_EXEEXT])
|
|
|
|
define([_AC_LANG_COMPILER_WORKS], [cross_compiling=maybe])
|
|
|
|
define([_AC_EXEEXT], [EXEEXT=])
|
|
|
|
define([AC_LINK_IFELSE],
|
|
[AC_FATAL([All the tests involving linking were disabled by $0])])
|
|
|
|
m4_divert_pop()dnl
|
|
])# # AC_NO_EXECUTABLES
|
|
|
|
|
|
# -------------------- #
|
|
# 3b. The C compiler. #
|
|
# -------------------- #
|
|
|
|
|
|
# _AC_PROG_PREPROC_WORKS
|
|
# ----------------------
|
|
# Check if $ac_cpp is a working preprocessor that can flag absent
|
|
# includes either by the exit status or by warnings
|
|
# Set ac_cpp_err to a non-empty value if the preprocessor failed
|
|
# This macro is for all languages, not only C
|
|
AC_DEFUN([_AC_PROG_PREPROC_WORKS],
|
|
[# Use a header file that comes with gcc, so configuring glibc
|
|
# with a fresh cross-compiler works.
|
|
# On the NeXT, cc -E runs the code through the compiler's parser,
|
|
# not just through cpp. "Syntax error" is here to catch this case.
|
|
AC_LANG_CONFTEST([AC_LANG_SOURCE([[#include <assert.h>
|
|
Syntax error]])])
|
|
ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag=maybe
|
|
_AC_TRY_CPP()
|
|
# Now check whether non-existent headers can be detected and how
|
|
# Skip if ac_cpp_err is not empty - ac_cpp is broken
|
|
if test -z "$ac_cpp_err"; then
|
|
AC_LANG_CONFTEST([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])])
|
|
_AC_TRY_CPP()
|
|
if test -z "$ac_cpp_err"; then
|
|
# cannot detect missing includes at all
|
|
ac_cpp_err=yes
|
|
else
|
|
if test "x$ac_cpp_err" = xmaybe; then
|
|
ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag=yes
|
|
else
|
|
ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag=
|
|
fi
|
|
ac_cpp_err=
|
|
fi
|
|
fi
|
|
rm -f conftest*
|
|
])# _AC_PROG_PREPROC_WORKS
|
|
|
|
|
|
# AC_PROG_CPP
|
|
# -----------
|
|
# Find a working C preprocessor
|
|
AC_DEFUN([AC_PROG_CPP],
|
|
[AC_MSG_CHECKING(how to run the C preprocessor)
|
|
AC_LANG_PUSH(C)dnl
|
|
# On Suns, sometimes $CPP names a directory.
|
|
if test -n "$CPP" && test -d "$CPP"; then
|
|
CPP=
|
|
fi
|
|
if test -z "$CPP"; then
|
|
AC_CACHE_VAL(ac_cv_prog_CPP,
|
|
[dnl
|
|
# Double quotes because CPP needs to be expanded
|
|
for CPP in "${CC-cc} -E" "${CC-cc} -E -traditional-cpp" "/lib/cpp"
|
|
do
|
|
_AC_PROG_PREPROC_WORKS()
|
|
if test -z "$ac_cpp_err"; then
|
|
break
|
|
fi
|
|
done
|
|
ac_cv_prog_CPP=$CPP
|
|
])dnl
|
|
CPP=$ac_cv_prog_CPP
|
|
else
|
|
_AC_PROG_PREPROC_WORKS()
|
|
ac_cv_prog_CPP=$CPP
|
|
fi
|
|
AC_MSG_RESULT($CPP)
|
|
if test -n "$ac_cpp_err"; then
|
|
AC_MSG_ERROR([C preprocessor "$CPP" fails sanity check])
|
|
fi
|
|
AC_SUBST(CPP)dnl
|
|
AC_LANG_POP()dnl
|
|
])# AC_PROG_CPP
|
|
|
|
|
|
# AC_LANG_COMPILER(C)
|
|
# -------------------
|
|
# Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
|
|
AC_DEFUN([AC_LANG_COMPILER(C)],
|
|
[AC_PROG_CC])
|
|
|
|
|
|
# ac_cv_prog_gcc
|
|
# --------------
|
|
# We used to name the cache variable this way.
|
|
AU_ALIAS([ac_cv_prog_gcc], [ac_cv_c_compiler_gnu])
|
|
|
|
|
|
# AC_PROG_CC([COMPILER ...])
|
|
# --------------------------
|
|
# COMPILER ... is a space separated list of C compilers to search for.
|
|
# This just gives the user an opportunity to specify an alternative
|
|
# search list for the C compiler.
|
|
AC_DEFUN([AC_PROG_CC],
|
|
[AC_BEFORE([$0], [AC_PROG_CPP])dnl
|
|
AC_LANG_PUSH(C)
|
|
AC_ARG_VAR([CC], [C compiler command])
|
|
AC_ARG_VAR([CFLAGS], [C compiler flags])
|
|
ifval([$1],
|
|
[AC_CHECK_TOOLS(CC, [$1])],
|
|
[AC_CHECK_TOOL(CC, gcc)
|
|
if test -z "$CC"; then
|
|
AC_CHECK_TOOL(CC, cc)
|
|
fi
|
|
if test -z "$CC"; then
|
|
AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
|
|
fi
|
|
if test -z "$CC"; then
|
|
AC_CHECK_TOOLS(CC, cl)
|
|
fi
|
|
])
|
|
|
|
test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
|
|
|
|
_AC_LANG_COMPILER_WORKS
|
|
_AC_LANG_COMPILER_GNU
|
|
GCC=`test $ac_compiler_gnu = yes && echo yes`
|
|
AC_EXPAND_ONCE([_AC_OBJEXT])
|
|
AC_EXPAND_ONCE([_AC_EXEEXT])
|
|
_AC_PROG_CC_G
|
|
AC_LANG_POP
|
|
])# AC_PROG_CC
|
|
|
|
|
|
# _AC_PROG_CC_G
|
|
# -------------
|
|
# Check whether -g works, even if CFLAGS is set, in case the package
|
|
# plays around with CFLAGS (such as to build both debugging and normal
|
|
# versions of a library), tasteless as that idea is.
|
|
define([_AC_PROG_CC_G],
|
|
[ac_test_CFLAGS=${CFLAGS+set}
|
|
ac_save_CFLAGS=$CFLAGS
|
|
CFLAGS="-g"
|
|
AC_CACHE_CHECK(whether ${CC-cc} accepts -g, ac_cv_prog_cc_g,
|
|
[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_prog_cc_g=yes],
|
|
[ac_cv_prog_cc_g=no])])
|
|
if test "$ac_test_CFLAGS" = set; then
|
|
CFLAGS=$ac_save_CFLAGS
|
|
elif test $ac_cv_prog_cc_g = yes; then
|
|
if test "$GCC" = yes; then
|
|
CFLAGS="-g -O2"
|
|
else
|
|
CFLAGS="-g"
|
|
fi
|
|
else
|
|
if test "$GCC" = yes; then
|
|
CFLAGS="-O2"
|
|
else
|
|
CFLAGS=
|
|
fi
|
|
fi[]dnl
|
|
])# _AC_PROG_CC_G
|
|
|
|
|
|
# AC_PROG_GCC_TRADITIONAL
|
|
# -----------------------
|
|
AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
|
|
[AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_PROG_CPP])dnl
|
|
if test $ac_cv_c_compiler_gnu = yes; then
|
|
AC_CACHE_CHECK(whether ${CC-cc} needs -traditional,
|
|
ac_cv_prog_gcc_traditional,
|
|
[ ac_pattern="Autoconf.*'x'"
|
|
AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
|
|
Autoconf TIOCGETP],
|
|
ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
|
|
|
|
if test $ac_cv_prog_gcc_traditional = no; then
|
|
AC_EGREP_CPP($ac_pattern, [#include <termio.h>
|
|
Autoconf TCGETA],
|
|
ac_cv_prog_gcc_traditional=yes)
|
|
fi])
|
|
if test $ac_cv_prog_gcc_traditional = yes; then
|
|
CC="$CC -traditional"
|
|
fi
|
|
fi
|
|
])# AC_PROG_GCC_TRADITIONAL
|
|
|
|
|
|
# AC_PROG_CC_C_O
|
|
# --------------
|
|
AC_DEFUN([AC_PROG_CC_C_O],
|
|
[AC_REQUIRE([AC_PROG_CC])dnl
|
|
if test "x$CC" != xcc; then
|
|
AC_MSG_CHECKING(whether $CC and cc understand -c and -o together)
|
|
else
|
|
AC_MSG_CHECKING(whether cc understands -c and -o together)
|
|
fi
|
|
set dummy $CC; ac_cc=`echo $[2] |
|
|
sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
|
|
AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
|
|
[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
|
|
# Make sure it works both with $CC and with simple cc.
|
|
# We do the test twice because some compilers refuse to overwrite an
|
|
# existing .o file with -o, though they will create one.
|
|
ac_try='${CC-cc} -c conftest.$ac_ext -o conftest.$ac_objext >&AC_FD_LOG'
|
|
if AC_TRY_EVAL(ac_try) &&
|
|
test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try);
|
|
then
|
|
eval ac_cv_prog_cc_${ac_cc}_c_o=yes
|
|
if test "x$CC" != xcc; then
|
|
# Test first that cc exists at all.
|
|
if AC_TRY_COMMAND(cc -c conftest.$ac_ext >&AC_FD_LOG); then
|
|
ac_try='cc -c conftest.$ac_ext -o conftest.$ac_objext >&AC_FD_LOG'
|
|
if AC_TRY_EVAL(ac_try) &&
|
|
test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try);
|
|
then
|
|
# cc works too.
|
|
:
|
|
else
|
|
# cc exists but doesn't like -o.
|
|
eval ac_cv_prog_cc_${ac_cc}_c_o=no
|
|
fi
|
|
fi
|
|
fi
|
|
else
|
|
eval ac_cv_prog_cc_${ac_cc}_c_o=no
|
|
fi
|
|
rm -f conftest*
|
|
])dnl
|
|
if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = yes"; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
|
|
[Define if your C compiler doesn't accept -c and -o together.])
|
|
fi
|
|
])# AC_PROG_CC_C_O
|
|
|
|
|
|
|
|
# ---------------------- #
|
|
# 3c. The C++ compiler. #
|
|
# ---------------------- #
|
|
|
|
|
|
# AC_PROG_CXXCPP
|
|
# --------------
|
|
# Find a working C++ preprocessor
|
|
AC_DEFUN([AC_PROG_CXXCPP],
|
|
[AC_MSG_CHECKING(how to run the C++ preprocessor)
|
|
AC_LANG_PUSH(C++)dnl
|
|
if test -z "$CXXCPP"; then
|
|
AC_CACHE_VAL(ac_cv_prog_CXXCPP,
|
|
[dnl
|
|
# Double quotes because CXXCPP needs to be expanded
|
|
for CXXCPP in "${CXX-g++} -E" "/lib/cpp"
|
|
do
|
|
_AC_PROG_PREPROC_WORKS()
|
|
if test -z "$ac_cpp_err"; then
|
|
break
|
|
fi
|
|
done
|
|
ac_cv_prog_CXXCPP=$CXXCPP
|
|
])dnl
|
|
CXXCPP=$ac_cv_prog_CXXCPP
|
|
else
|
|
_AC_PROG_PREPROC_WORKS()
|
|
ac_cv_prog_CXXCPP=$CXXCPP
|
|
fi
|
|
AC_MSG_RESULT($CXXCPP)
|
|
if test -n "$ac_cpp_err"; then
|
|
AC_MSG_ERROR([C++ preprocessor "$CXXCPP" fails sanity check])
|
|
fi
|
|
AC_SUBST(CXXCPP)dnl
|
|
AC_LANG_POP()dnl
|
|
])# AC_PROG_CXXCPP
|
|
|
|
|
|
# AC_LANG_COMPILER(C++)
|
|
# ---------------------
|
|
# Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
|
|
AC_DEFUN([AC_LANG_COMPILER(C++)],
|
|
[AC_PROG_CXX])
|
|
|
|
|
|
# ac_cv_prog_gxx
|
|
# --------------
|
|
# We used to name the cache variable this way.
|
|
AU_ALIAS([ac_cv_prog_gxx], [ac_cv_cxx_compiler_gnu])
|
|
|
|
|
|
# AC_PROG_CXX([LIST-OF-COMPILERS])
|
|
# --------------------------------
|
|
# LIST-OF-COMPILERS is a space separated list of C++ compilers to search
|
|
# for (if not specified, a default list is used). This just gives the
|
|
# user an opportunity to specify an alternative search list for the C++
|
|
# compiler.
|
|
# aCC HP-UX C++ compiler much better than `CC', so test before.
|
|
# KCC KAI C++ compiler
|
|
# RCC Rational C++
|
|
# xlC_r AIX C Set++ (with support for reentrant code)
|
|
# xlC AIX C Set++
|
|
AC_DEFUN([AC_PROG_CXX],
|
|
[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
|
|
AC_LANG_PUSH(C++)
|
|
AC_ARG_VAR([CXX], [C++ compiler command])
|
|
AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])
|
|
AC_CHECK_TOOLS(CXX,
|
|
[$CCC m4_default([$1],
|
|
[g++ c++ gpp aCC CC cxx cc++ cl KCC RCC xlC_r xlC])],
|
|
g++)
|
|
|
|
_AC_LANG_COMPILER_WORKS
|
|
_AC_LANG_COMPILER_GNU
|
|
GXX=`test $ac_compiler_gnu = yes && echo yes`
|
|
AC_EXPAND_ONCE([_AC_OBJEXT])
|
|
AC_EXPAND_ONCE([_AC_EXEEXT])
|
|
_AC_PROG_CXX_G
|
|
AC_LANG_POP
|
|
])# AC_PROG_CXX
|
|
|
|
|
|
# _AC_PROG_CXX_G
|
|
# --------------
|
|
# Check whether -g works, even if CXXFLAGS is set, in case the package
|
|
# plays around with CXXFLAGS (such as to build both debugging and
|
|
# normal versions of a library), tasteless as that idea is.
|
|
define([_AC_PROG_CXX_G],
|
|
[ac_test_CXXFLAGS=${CXXFLAGS+set}
|
|
ac_save_CXXFLAGS=$CXXFLAGS
|
|
CXXFLAGS="-g"
|
|
AC_CACHE_CHECK(whether ${CXX-g++} accepts -g, ac_cv_prog_cxx_g,
|
|
[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
|
|
[ac_cv_prog_cxx_g=yes],
|
|
[ac_cv_prog_cxx_g=no])])
|
|
if test "$ac_test_CXXFLAGS" = set; then
|
|
CXXFLAGS=$ac_save_CXXFLAGS
|
|
elif test $ac_cv_prog_cxx_g = yes; then
|
|
if test "$GXX" = yes; then
|
|
CXXFLAGS="-g -O2"
|
|
else
|
|
CXXFLAGS="-g"
|
|
fi
|
|
else
|
|
if test "$GXX" = yes; then
|
|
CXXFLAGS="-O2"
|
|
else
|
|
CXXFLAGS=
|
|
fi
|
|
fi[]dnl
|
|
])# _AC_PROG_CXX_G
|
|
|
|
|
|
|
|
# ----------------------------- #
|
|
# 3d. The Fortran 77 compiler. #
|
|
# ----------------------------- #
|
|
|
|
|
|
# AC_LANG_COMPILER(Fortran 77)
|
|
# ----------------------------
|
|
# Find the Fortran 77 compiler. Must be AC_DEFUN'd to be
|
|
# AC_REQUIRE'able.
|
|
AC_DEFUN([AC_LANG_COMPILER(Fortran 77)],
|
|
[AC_PROG_F77])
|
|
|
|
|
|
# ac_cv_prog_g77
|
|
# --------------
|
|
# We used to name the cache variable this way.
|
|
AU_ALIAS([ac_cv_prog_g77], [ac_cv_f77_compiler_gnu])
|
|
|
|
|
|
# AC_PROG_F77([COMPILERS...])
|
|
# ---------------------------
|
|
# COMPILERS is a space separated list of Fortran 77 compilers to search
|
|
# for.
|
|
# Fortran 95 isn't strictly backwards-compatiable with Fortran 77, but
|
|
# `f95' is worth trying.
|
|
#
|
|
# Compilers are ordered by
|
|
# 1. F77, F90, F95
|
|
# 2. Good native compilers, bad native compilers, wrappers around f2c.
|
|
#
|
|
# `fort77' and `fc' are wrappers around `f2c', `fort77' being better.
|
|
# It is believed that under HP-UX `fort77' is the name of the native
|
|
# compiler. NAG f95 is preferred over `fc', so put `fc' last.
|
|
# pgf77 is the Portland Group f77 compiler.
|
|
# lf95 is the Lahey-Fujitsu compiler.
|
|
AC_DEFUN([AC_PROG_F77],
|
|
[AC_LANG_PUSH(Fortran 77)
|
|
AC_ARG_VAR([F77], [Fortran 77 compiler command])
|
|
AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])
|
|
AC_CHECK_TOOLS(F77,
|
|
[m4_default([$1],
|
|
[g77 f77 xlf cf77 pgf77 fl32 fort77 f90 xlf90 f95 lf95 fc])])
|
|
|
|
_AC_LANG_COMPILER_WORKS
|
|
_AC_LANG_COMPILER_GNU
|
|
G77=`test $ac_compiler_gnu = yes && echo yes`
|
|
AC_EXPAND_ONCE([_AC_OBJEXT])
|
|
AC_EXPAND_ONCE([_AC_EXEEXT])
|
|
_AC_PROG_F77_G
|
|
AC_LANG_POP
|
|
])# AC_PROG_F77
|
|
|
|
|
|
# _AC_PROG_F77_G
|
|
# --------------
|
|
# Check whether -g works, even if FFLAGS is set, in case the package
|
|
# plays around with FFLAGS (such as to build both debugging and normal
|
|
# versions of a library), tasteless as that idea is.
|
|
define([_AC_PROG_F77_G],
|
|
[ac_test_FFLAGS=${FFLAGS+set}
|
|
ac_save_FFLAGS=$FFLAGS
|
|
FFLAGS=
|
|
AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g,
|
|
[FFLAGS=-g
|
|
_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
|
|
[ac_cv_prog_f77_g=yes],
|
|
[ac_cv_prog_f77_g=no])
|
|
])
|
|
if test "$ac_test_FFLAGS" = set; then
|
|
FFLAGS=$ac_save_FFLAGS
|
|
elif test $ac_cv_prog_f77_g = yes; then
|
|
if test "$G77" = yes; then
|
|
FFLAGS="-g -O2"
|
|
else
|
|
FFLAGS="-g"
|
|
fi
|
|
else
|
|
if test "$G77" = yes; then
|
|
FFLAGS="-O2"
|
|
else
|
|
FFLAGS=
|
|
fi
|
|
fi[]dnl
|
|
])# _AC_PROG_F77_G
|
|
|
|
|
|
# AC_PROG_F77_C_O
|
|
# ---------------
|
|
# Test if the Fortran 77 compiler accepts the options `-c' and `-o'
|
|
# simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not.
|
|
#
|
|
# The usefulness of this macro is questionable, as I can't really see
|
|
# why anyone would use it. The only reason I include it is for
|
|
# completeness, since a similar test exists for the C compiler.
|
|
AC_DEFUN([AC_PROG_F77_C_O],
|
|
[AC_REQUIRE([AC_PROG_F77])dnl
|
|
AC_CACHE_CHECK([whether $F77 understand -c and -o together],
|
|
[ac_cv_prog_f77_c_o],
|
|
[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
|
|
# We do the `AC_TRY_EVAL' test twice because some compilers refuse to
|
|
# overwrite an existing `.o' file with `-o', although they will create
|
|
# one.
|
|
ac_try='$F77 $FFLAGS -c conftest.$ac_ext -o conftest.$ac_objext >&AC_FD_LOG'
|
|
if AC_TRY_EVAL(ac_try) && test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try); then
|
|
ac_cv_prog_f77_c_o=yes
|
|
else
|
|
ac_cv_prog_f77_c_o=no
|
|
fi
|
|
rm -f conftest*])
|
|
if test $ac_cv_prog_f77_c_o = yes; then
|
|
AC_DEFINE(F77_NO_MINUS_C_MINUS_O, 1,
|
|
[Define if your Fortran 77 compiler doesn't accept -c and -o together.])
|
|
fi
|
|
])# AC_PROG_F77_C_O
|
|
|
|
|
|
|
|
|
|
|
|
## ------------------------------- ##
|
|
## 4. Compilers' characteristics. ##
|
|
## ------------------------------- ##
|
|
|
|
|
|
# -------------------------------- #
|
|
# 4b. C compiler characteristics. #
|
|
# -------------------------------- #
|
|
|
|
# AC_PROG_CC_STDC
|
|
# ---------------
|
|
# If the C compiler in not in ANSI C mode by default, try to add an
|
|
# option to output variable @code{CC} to make it so. This macro tries
|
|
# various options that select ANSI C on some system or another. It
|
|
# considers the compiler to be in ANSI C mode if it handles function
|
|
# prototypes correctly.
|
|
AC_DEFUN([AC_PROG_CC_STDC],
|
|
[AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_BEFORE([$0], [AC_C_INLINE])dnl
|
|
AC_BEFORE([$0], [AC_C_CONST])dnl
|
|
dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require
|
|
dnl a magic option to avoid problems with ANSI preprocessor commands
|
|
dnl like #elif.
|
|
dnl FIXME: can't do this because then AC_AIX won't work due to a
|
|
dnl circular dependency.
|
|
dnl AC_BEFORE([$0], [AC_PROG_CPP])
|
|
AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C)
|
|
AC_CACHE_VAL(ac_cv_prog_cc_stdc,
|
|
[ac_cv_prog_cc_stdc=no
|
|
ac_save_CC=$CC
|
|
# Don't try gcc -ansi; that turns off useful extensions and
|
|
# breaks some systems' header files.
|
|
# AIX -qlanglvl=ansi
|
|
# Ultrix and OSF/1 -std1
|
|
# HP-UX 10.20 and later -Ae
|
|
# HP-UX older versions -Aa -D_HPUX_SOURCE
|
|
# SVR4 -Xc -D__EXTENSIONS__
|
|
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
|
|
do
|
|
CC="$ac_save_CC $ac_arg"
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
|
|
struct buf { int x; };
|
|
FILE * (*rcsopen) (struct buf *, struct stat *, int);
|
|
static char *e (p, i)
|
|
char **p;
|
|
int i;
|
|
{
|
|
return p[i];
|
|
}
|
|
static char *f (char * (*g) (char **, int), char **p, ...)
|
|
{
|
|
char *s;
|
|
va_list v;
|
|
va_start (v,p);
|
|
s = g (p, va_arg (v,int));
|
|
va_end (v);
|
|
return s;
|
|
}
|
|
int test (int i, double x);
|
|
struct s1 {int (*f) (int a);};
|
|
struct s2 {int (*f) (double a);};
|
|
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
|
|
int argc;
|
|
char **argv;]],
|
|
[[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]])],
|
|
[ac_cv_prog_cc_stdc=$ac_arg; break])
|
|
done
|
|
CC=$ac_save_CC
|
|
])
|
|
case "x$ac_cv_prog_cc_stdc" in
|
|
x|xno)
|
|
AC_MSG_RESULT([none needed]) ;;
|
|
*)
|
|
AC_MSG_RESULT($ac_cv_prog_cc_stdc)
|
|
CC="$CC $ac_cv_prog_cc_stdc" ;;
|
|
esac
|
|
])# AC_PROG_CC_STDC
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([AC_C_CROSS],
|
|
[AC_OBSOLETE([$0], [; it has been merged into AC_PROG_CC])])
|
|
|
|
|
|
# AC_C_CHAR_UNSIGNED
|
|
# ------------------
|
|
AC_DEFUN([AC_C_CHAR_UNSIGNED],
|
|
[AH_VERBATIM([__CHAR_UNSIGNED__],
|
|
[/* Define if type `char' is unsigned and you are not using gcc. */
|
|
#ifndef __CHAR_UNSIGNED__
|
|
# undef __CHAR_UNSIGNED__
|
|
#endif])dnl
|
|
AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
|
|
[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
|
|
[((char) -1) < 0])],
|
|
ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
|
|
if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
|
|
AC_DEFINE(__CHAR_UNSIGNED__)
|
|
fi
|
|
])# AC_C_CHAR_UNSIGNED
|
|
|
|
|
|
# AC_C_LONG_DOUBLE
|
|
# ----------------
|
|
AC_DEFUN([AC_C_LONG_DOUBLE],
|
|
[AC_CACHE_CHECK(for long double, ac_cv_c_long_double,
|
|
[if test "$GCC" = yes; then
|
|
ac_cv_c_long_double=yes
|
|
else
|
|
AC_TRY_RUN(
|
|
[int
|
|
main ()
|
|
{
|
|
/* The Stardent Vistra knows sizeof(long double), but does not
|
|
support it. */
|
|
long double foo = 0.0;
|
|
/* On Ultrix 4.3 cc, long double is 4 and double is 8. */
|
|
exit (sizeof (long double) < sizeof (double));
|
|
}],
|
|
ac_cv_c_long_double=yes, ac_cv_c_long_double=no)
|
|
fi])
|
|
if test $ac_cv_c_long_double = yes; then
|
|
AC_DEFINE(HAVE_LONG_DOUBLE, 1,
|
|
[Define if the `long double' type works.])
|
|
fi
|
|
])# AC_C_LONG_DOUBLE
|
|
|
|
|
|
# AC_C_BIGENDIAN
|
|
# --------------
|
|
AC_DEFUN([AC_C_BIGENDIAN],
|
|
[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
|
|
[ac_cv_c_bigendian=unknown
|
|
# See if sys/param.h defines the BYTE_ORDER macro.
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
],
|
|
[#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
|
|
bogus endian macros
|
|
#endif
|
|
])],
|
|
[# It does; now see whether it defined to BIG_ENDIAN or not.
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
], [#if BYTE_ORDER != BIG_ENDIAN
|
|
not big endian
|
|
#endif
|
|
])], [ac_cv_c_bigendian=yes],
|
|
[ac_cv_c_bigendian=no])])
|
|
if test $ac_cv_c_bigendian = unknown; then
|
|
AC_TRY_RUN(
|
|
[int
|
|
main ()
|
|
{
|
|
/* Are we little or big endian? From Harbison&Steele. */
|
|
union
|
|
{
|
|
long l;
|
|
char c[sizeof (long)];
|
|
} u;
|
|
u.l = 1;
|
|
exit (u.c[sizeof (long) - 1] == 1);
|
|
}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes)
|
|
fi])
|
|
if test $ac_cv_c_bigendian = yes; then
|
|
AC_DEFINE(WORDS_BIGENDIAN, 1,
|
|
[Define if your processor stores words with the most significant
|
|
byte first (like Motorola and SPARC, unlike Intel and VAX).])
|
|
fi
|
|
])# AC_C_BIGENDIAN
|
|
|
|
|
|
# AC_C_INLINE
|
|
# -----------
|
|
# Do nothing if the compiler accepts the inline keyword.
|
|
# Otherwise define inline to __inline__ or __inline if one of those work,
|
|
# otherwise define inline to be empty.
|
|
AC_DEFUN([AC_C_INLINE],
|
|
[AC_REQUIRE([AC_PROG_CC_STDC])dnl
|
|
AC_CACHE_CHECK([for inline], ac_cv_c_inline,
|
|
[ac_cv_c_inline=no
|
|
for ac_kw in inline __inline__ __inline; do
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE(
|
|
[#ifndef __cplusplus
|
|
$ac_kw int foo () {return 0; }
|
|
#endif
|
|
])],
|
|
[ac_cv_c_inline=$ac_kw; break])
|
|
done
|
|
])
|
|
case $ac_cv_c_inline in
|
|
inline | yes) ;;
|
|
no) AC_DEFINE(inline,,
|
|
[Define as `__inline' if that's what the C compiler calls it,
|
|
or to nothing if it is not supported.]) ;;
|
|
*) AC_DEFINE_UNQUOTED(inline, $ac_cv_c_inline) ;;
|
|
esac
|
|
])# AC_C_INLINE
|
|
|
|
|
|
# AC_C_CONST
|
|
# ----------
|
|
AC_DEFUN([AC_C_CONST],
|
|
[AC_REQUIRE([AC_PROG_CC_STDC])dnl
|
|
AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
|
|
[[/* FIXME: Include the comments suggested by Paul. */
|
|
#ifndef __cplusplus
|
|
/* Ultrix mips cc rejects this. */
|
|
typedef int charset[2];
|
|
const charset x;
|
|
/* SunOS 4.1.1 cc rejects this. */
|
|
char const *const *ccp;
|
|
char **p;
|
|
/* NEC SVR4.0.2 mips cc rejects this. */
|
|
struct point {int x, y;};
|
|
static struct point const zero = {0,0};
|
|
/* AIX XL C 1.02.0.0 rejects this.
|
|
It does not let you subtract one const X* pointer from another in
|
|
an arm of an if-expression whose if-part is not a constant
|
|
expression */
|
|
const char *g = "string";
|
|
ccp = &g + (g ? g-g : 0);
|
|
/* HPUX 7.0 cc rejects these. */
|
|
++ccp;
|
|
p = (char**) ccp;
|
|
ccp = (char const *const *) p;
|
|
{ /* SCO 3.2v4 cc rejects this. */
|
|
char *t;
|
|
char const *s = 0 ? (char *) 0 : (char const *) 0;
|
|
|
|
*t++ = 0;
|
|
}
|
|
{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
|
|
int x[] = {25, 17};
|
|
const int *foo = &x[0];
|
|
++foo;
|
|
}
|
|
{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
|
|
typedef const int *iptr;
|
|
iptr p = 0;
|
|
++p;
|
|
}
|
|
{ /* AIX XL C 1.02.0.0 rejects this saying
|
|
"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
|
|
struct s { int j; const int *ap[3]; };
|
|
struct s *b; b->j = 5;
|
|
}
|
|
{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
|
|
const int foo = 10;
|
|
}
|
|
#endif
|
|
]])],
|
|
[ac_cv_c_const=yes],
|
|
[ac_cv_c_const=no])])
|
|
if test $ac_cv_c_const = no; then
|
|
AC_DEFINE(const,,
|
|
[Define to empty if `const' does not conform to ANSI C.])
|
|
fi
|
|
])# AC_C_CONST
|
|
|
|
|
|
# AC_C_VOLATILE
|
|
# -------------
|
|
# Note that, unlike const, #defining volatile to be the empty string can
|
|
# actually turn a correct program into an incorrect one, since removing
|
|
# uses of volatile actually grants the compiler permission to perform
|
|
# optimizations that could break the user's code. So, do not #define
|
|
# volatile away unless it is really necessary to allow the user's code
|
|
# to compile cleanly. Benign compiler failures should be tolerated.
|
|
AC_DEFUN([AC_C_VOLATILE],
|
|
[AC_REQUIRE([AC_PROG_CC_STDC])dnl
|
|
AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
|
|
volatile int x;
|
|
int * volatile y;])],
|
|
[ac_cv_c_volatile=yes],
|
|
[ac_cv_c_volatile=no])])
|
|
if test $ac_cv_c_volatile = no; then
|
|
AC_DEFINE(volatile,,
|
|
[Define to empty if the keyword `volatile' does not work.
|
|
Warning: valid code using `volatile' can become incorrect
|
|
without. Disable with care.])
|
|
fi
|
|
])# AC_C_VOLATILE
|
|
|
|
|
|
# AC_C_STRINGIZE
|
|
# --------------
|
|
# Checks if `#' can be used to glue strings together at the CPP level.
|
|
# Defines HAVE_STRINGIZE if positive.
|
|
AC_DEFUN([AC_C_STRINGIZE],
|
|
[AC_REQUIRE([AC_PROG_CPP])dnl
|
|
AC_MSG_CHECKING([for preprocessor stringizing operator])
|
|
AC_CACHE_VAL(ac_cv_c_stringize,
|
|
AC_EGREP_CPP([#teststring],[
|
|
#define x(y) #y
|
|
|
|
char *s = x(teststring);
|
|
], ac_cv_c_stringize=no, ac_cv_c_stringize=yes))
|
|
if test "${ac_cv_c_stringize}" = yes; then
|
|
AC_DEFINE(HAVE_STRINGIZE, 1,
|
|
[Define if cpp supports the ANSI # stringizing operator.])
|
|
fi
|
|
AC_MSG_RESULT([${ac_cv_c_stringize}])
|
|
])# AC_C_STRINGIZE
|
|
|
|
|
|
# AC_C_PROTOTYPES
|
|
# ---------------
|
|
# Check if the C compiler supports prototypes, included if it needs
|
|
# options.
|
|
AC_DEFUN([AC_C_PROTOTYPES],
|
|
[AC_REQUIRE([AC_PROG_CC_STDC])dnl
|
|
AC_REQUIRE([AC_PROG_CPP])dnl
|
|
AC_MSG_CHECKING([for function prototypes])
|
|
if test "$ac_cv_prog_cc_stdc" != no; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(PROTOTYPES, 1,
|
|
[Define if the C compiler supports function prototypes.])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
])# AC_C_PROTOTYPES
|
|
|
|
|
|
|
|
|
|
# ---------------------------------------- #
|
|
# 4d. Fortan 77 compiler characteristics. #
|
|
# ---------------------------------------- #
|
|
|
|
|
|
# _AC_PROG_F77_V_OUTPUT([FLAG = $ac_cv_prog_f77_v])
|
|
# -------------------------------------------------
|
|
# Link a trivial Fortran program, compiling with a verbose output FLAG
|
|
# (which default value, $ac_cv_prog_f77_v, is computed by
|
|
# _AC_PROG_F77_V), and return the output in $ac_f77_v_output. This
|
|
# output is processed in the way expected by AC_F77_LIBRARY_LDFLAGS,
|
|
# so that any link flags that are echoed by the compiler appear as
|
|
# space-separated items.
|
|
AC_DEFUN([_AC_PROG_F77_V_OUTPUT],
|
|
[AC_REQUIRE([AC_PROG_F77])dnl
|
|
AC_LANG_PUSH(Fortran 77)
|
|
|
|
AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
|
|
|
|
# Compile and link our simple test program by passing a flag
|
|
# (argument 1 to this macro) to the Fortran 77 compiler in
|
|
# order to get "verbose" output that we can then parse for the
|
|
# Fortran 77 linker flags.
|
|
ac_save_FFLAGS=$FFLAGS
|
|
FFLAGS="$FFLAGS m4_default([$1], [$ac_cv_prog_f77_v])"
|
|
(eval echo configure:__oline__: \"$ac_link\") >&AC_FD_LOG
|
|
ac_f77_v_output=`eval $ac_link AC_FD_LOG>&1 2>&1 | grep -v 'Driving:'`
|
|
echo "$ac_f77_v_output" >&AC_FD_LOG
|
|
FFLAGS=$ac_save_FFLAGS
|
|
|
|
rm -f conftest.*
|
|
AC_LANG_POP()dnl
|
|
|
|
# If we are using xlf then replace all the commas with spaces.
|
|
if echo $ac_f77_v_output | grep xlfentry >/dev/null 2>&1; then
|
|
ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'`
|
|
fi
|
|
|
|
# If we are using Cray Fortran then delete quotes.
|
|
# Use "\"" instead of '"' for font-lock-mode.
|
|
# FIXME: a more general fix for quoted arguments with spaces?
|
|
if echo $ac_f77_v_output | grep cft90 >/dev/null 2>&1; then
|
|
ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"`
|
|
fi[]dnl
|
|
])# _AC_PROG_F77_V_OUTPUT
|
|
|
|
|
|
# _AC_PROG_F77_V
|
|
# --------------
|
|
#
|
|
# Determine the flag that causes the Fortran 77 compiler to print
|
|
# information of library and object files (normally -v)
|
|
# Needed for AC_F77_LIBRARY_FLAGS
|
|
# Some compilers don't accept -v (Lahey: -verbose, xlf: -V)
|
|
AC_DEFUN([_AC_PROG_F77_V],
|
|
[AC_REQUIRE([AC_PROG_F77])dnl
|
|
AC_CACHE_CHECK([how to get verbose linking output from $F77],
|
|
[ac_cv_prog_f77_v],
|
|
[AC_LANG_PUSH(Fortran 77)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
|
|
[ac_cv_prog_f77_v=
|
|
# Try some options frequently used verbose output
|
|
for ac_verb in -v -verbose --verbose -V; do
|
|
_AC_PROG_F77_V_OUTPUT($ac_verb)
|
|
# look for -l* and *.a constructs in the output
|
|
for ac_arg in $ac_f77_v_output; do
|
|
case $ac_arg in
|
|
[[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*)
|
|
ac_cv_prog_f77_v=$ac_verb
|
|
break 2 ;;
|
|
esac
|
|
done
|
|
done
|
|
if test -z "$ac_cv_prog_f77_v"; then
|
|
AC_MSG_WARN([cannot determine how to obtain linking information from $F77])
|
|
fi],
|
|
[AC_MSG_WARN([compilation failed])])
|
|
AC_LANG_POP()dnl
|
|
])]) # _AC_PROG_F77_V
|
|
|
|
|
|
# AC_F77_LIBRARY_LDFLAGS
|
|
# ----------------------
|
|
#
|
|
# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 77
|
|
# intrinsic and run-time libraries that are required to successfully
|
|
# link a Fortran 77 program or shared library. The output variable
|
|
# FLIBS is set to these flags.
|
|
#
|
|
# This macro is intended to be used in those situations when it is
|
|
# necessary to mix, e.g. C++ and Fortran 77, source code into a single
|
|
# program or shared library.
|
|
#
|
|
# For example, if object files from a C++ and Fortran 77 compiler must
|
|
# be linked together, then the C++ compiler/linker must be used for
|
|
# linking (since special C++-ish things need to happen at link time
|
|
# like calling global constructors, instantiating templates, enabling
|
|
# exception support, etc.).
|
|
#
|
|
# However, the Fortran 77 intrinsic and run-time libraries must be
|
|
# linked in as well, but the C++ compiler/linker doesn't know how to
|
|
# add these Fortran 77 libraries. Hence, the macro
|
|
# "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran 77
|
|
# libraries.
|
|
#
|
|
# This macro was packaged in its current form by Matthew D. Langston.
|
|
# However, nearly all of this macro came from the "OCTAVE_FLIBS" macro
|
|
# in "octave-2.0.13/aclocal.m4", and full credit should go to John
|
|
# W. Eaton for writing this extremely useful macro. Thank you John.
|
|
AC_DEFUN([AC_F77_LIBRARY_LDFLAGS],
|
|
[AC_REQUIRE([AC_PROG_F77])dnl
|
|
_AC_PROG_F77_V
|
|
AC_CACHE_CHECK([for Fortran 77 libraries], ac_cv_flibs,
|
|
[if test "x$FLIBS" != "x"; then
|
|
ac_cv_flibs="$FLIBS" # Let the user override the test.
|
|
else
|
|
|
|
_AC_PROG_F77_V_OUTPUT
|
|
|
|
ac_cv_flibs=
|
|
|
|
# Save positional arguments (if any)
|
|
ac_save_positional="$[@]"
|
|
|
|
set X $ac_f77_v_output
|
|
while test $[@%:@] != 1; do
|
|
shift
|
|
ac_arg=$[1]
|
|
case $ac_arg in
|
|
[[\\/]]*.a | ?:[[\\/]]*.a)
|
|
AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, ,
|
|
ac_cv_flibs="$ac_cv_flibs $ac_arg")
|
|
;;
|
|
-bI:*)
|
|
AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, ,
|
|
[AC_LINKER_OPTION([$ac_arg], ac_cv_flibs)])
|
|
;;
|
|
# Ignore these flags.
|
|
-lang* | -lcrt0.o | -lc | -lgcc | -LANG:=*)
|
|
;;
|
|
-lkernel32)
|
|
test x"$CYGWIN" != xyes && ac_cv_flibs="$ac_cv_flibs $ac_arg"
|
|
;;
|
|
-[[LRuY]])
|
|
# These flags, when seen by themselves, take an argument.
|
|
# We remove the space between option and argument and re-iterate
|
|
# unless we find an empty arg or a new option (starting with -)
|
|
case $[2] in
|
|
"" | -*);;
|
|
*)
|
|
ac_arg="$ac_arg$[2]"
|
|
shift; shift
|
|
set X $ac_arg "$[@]"
|
|
;;
|
|
esac
|
|
;;
|
|
-YP,*)
|
|
for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
|
|
AC_LIST_MEMBER_OF($ac_j, $ac_cv_flibs, ,
|
|
[ac_arg="$ac_arg $ac_j"
|
|
ac_cv_flibs="$ac_cv_flibs $ac_j"])
|
|
done
|
|
;;
|
|
-[[lLR]]*)
|
|
AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, ,
|
|
ac_cv_flibs="$ac_cv_flibs $ac_arg")
|
|
;;
|
|
# Ignore everything else.
|
|
esac
|
|
done
|
|
# restore positional arguments
|
|
set X $ac_save_positional; shift
|
|
|
|
# We only consider "LD_RUN_PATH" on Solaris systems. If this is seen,
|
|
# then we insist that the "run path" must be an absolute path (i.e. it
|
|
# must begin with a "/").
|
|
case `(uname -sr) 2>/dev/null` in
|
|
"SunOS 5"*)
|
|
ac_ld_run_path=`echo $ac_f77_v_output |
|
|
sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'`
|
|
test "x$ac_ld_run_path" != x &&
|
|
AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_flibs)
|
|
;;
|
|
esac
|
|
fi # test "x$FLIBS" = "x"
|
|
])
|
|
FLIBS="$ac_cv_flibs"
|
|
AC_SUBST(FLIBS)
|
|
])# AC_F77_LIBRARY_LDFLAGS
|
|
|
|
|
|
# _AC_F77_NAME_MANGLING
|
|
# ---------------------
|
|
# Test for the name mangling scheme used by the Fortran 77 compiler.
|
|
#
|
|
# Sets ac_cv_f77_mangling. The value contains three fields, separated by commas:
|
|
#
|
|
# lower case / upper case:
|
|
# case translation of the Fortan 77 symbols
|
|
# underscore / no underscore:
|
|
# whether the compiler appends "_" to symbol names
|
|
# extra underscore / no extra underscore:
|
|
# whether the compiler appends an extra "_" to symbol names already
|
|
# containing at least one underscore
|
|
#
|
|
AC_DEFUN([_AC_F77_NAME_MANGLING],
|
|
[AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_PROG_F77])dnl
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
|
|
AC_CACHE_CHECK([for Fortran 77 name-mangling scheme],
|
|
ac_cv_f77_mangling,
|
|
[AC_LANG_PUSH(Fortran 77)
|
|
AC_COMPILE_IFELSE(
|
|
[ subroutine foobar()
|
|
return
|
|
end
|
|
subroutine foo_bar()
|
|
return
|
|
end],
|
|
[mv conftest.${ac_objext} cf77_test.${ac_objext}
|
|
|
|
AC_LANG_PUSH(C)
|
|
|
|
ac_save_LIBS=$LIBS
|
|
LIBS="cf77_test.${ac_objext} $FLIBS $LIBS"
|
|
|
|
ac_success=no
|
|
for ac_foobar in foobar FOOBAR; do
|
|
for ac_underscore in "" "_"; do
|
|
ac_func="$ac_foobar$ac_underscore"
|
|
AC_TRY_LINK_FUNC($ac_func,
|
|
[ac_success=yes; break 2])
|
|
done
|
|
done
|
|
|
|
if test "$ac_success" = "yes"; then
|
|
case $ac_foobar in
|
|
foobar)
|
|
ac_case=lower
|
|
ac_foo_bar=foo_bar
|
|
;;
|
|
FOOBAR)
|
|
ac_case=upper
|
|
ac_foo_bar=FOO_BAR
|
|
;;
|
|
esac
|
|
|
|
ac_success_extra=no
|
|
for ac_extra in "" "_"; do
|
|
ac_func="$ac_foo_bar$ac_underscore$ac_extra"
|
|
AC_TRY_LINK_FUNC($ac_func,
|
|
[ac_success_extra=yes; break])
|
|
done
|
|
|
|
if test "$ac_success_extra" = "yes"; then
|
|
ac_cv_f77_mangling="$ac_case case"
|
|
if test -z "$ac_underscore"; then
|
|
ac_cv_f77_mangling="$ac_cv_f77_mangling, no underscore"
|
|
else
|
|
ac_cv_f77_mangling="$ac_cv_f77_mangling, underscore"
|
|
fi
|
|
if test -z "$ac_extra"; then
|
|
ac_cv_f77_mangling="$ac_cv_f77_mangling, no extra underscore"
|
|
else
|
|
ac_cv_f77_mangling="$ac_cv_f77_mangling, extra underscore"
|
|
fi
|
|
else
|
|
ac_cv_f77_mangling="unknown"
|
|
fi
|
|
else
|
|
ac_cv_f77_mangling="unknown"
|
|
fi
|
|
|
|
LIBS=$ac_save_LIBS
|
|
AC_LANG_POP()dnl
|
|
rm -f cf77_test* conftest*])
|
|
AC_LANG_POP()dnl
|
|
])
|
|
])# _AC_F77_NAME_MANGLING
|
|
|
|
# The replacement is empty.
|
|
AU_DEFUN([AC_F77_NAME_MANGLING], [])
|
|
|
|
|
|
# AC_F77_WRAPPERS
|
|
# ---------------
|
|
# Defines C macros F77_FUNC(name,NAME) and F77_FUNC_(name,NAME) to
|
|
# properly mangle the names of C identifiers, and C identifiers with
|
|
# underscores, respectively, so that they match the name mangling
|
|
# scheme used by the Fortran 77 compiler.
|
|
AC_DEFUN([AC_F77_WRAPPERS],
|
|
[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
|
|
AH_TEMPLATE([F77_FUNC],
|
|
[Define to a macro mangling the given C identifier (in lower and upper
|
|
case), which must not contain underscores, for linking with Fortran.])dnl
|
|
AH_TEMPLATE([F77_FUNC_],
|
|
[As F77_FUNC, but for C identifiers containing underscores.])dnl
|
|
case $ac_cv_f77_mangling in
|
|
"lower case, no underscore, no extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [name])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [name]) ;;
|
|
"lower case, no underscore, extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [name])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;;
|
|
"lower case, underscore, no extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [name ## _])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;;
|
|
"lower case, underscore, extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [name ## _])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [name ## __]) ;;
|
|
"upper case, no underscore, no extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [NAME])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [NAME]) ;;
|
|
"upper case, no underscore, extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [NAME])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;;
|
|
"upper case, underscore, no extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;;
|
|
"upper case, underscore, extra underscore")
|
|
AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _])
|
|
AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## __]) ;;
|
|
*)
|
|
AC_MSG_WARN(unknown Fortran 77 name-mangling scheme)
|
|
;;
|
|
esac
|
|
])# AC_F77_WRAPPERS
|
|
|
|
|
|
# AC_F77_FUNC(NAME, [SHELLVAR = NAME])
|
|
# ------------------------------------
|
|
# For a Fortran subroutine of given NAME, define a shell variable
|
|
# $SHELLVAR to the Fortran-77 mangled name. If the SHELLVAR
|
|
# argument is not supplied, it defaults to NAME.
|
|
AC_DEFUN([AC_F77_FUNC],
|
|
[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
|
|
case $ac_cv_f77_mangling in
|
|
upper*) ac_val="m4_toupper([$1])" ;;
|
|
lower*) ac_val="m4_tolower([$1])" ;;
|
|
*) ac_val="unknown" ;;
|
|
esac
|
|
case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
|
|
ifelse(m4_index([$1],[_]),-1,[],
|
|
[case $ac_cv_f77_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac
|
|
])
|
|
m4_default([$2],[$1])="$ac_val"
|
|
]) # AC_F77_FUNC
|