diff options
Diffstat (limited to '')
| -rw-r--r-- | aclang.m4 | 2194 |
1 files changed, 2194 insertions, 0 deletions
diff --git a/aclang.m4 b/aclang.m4 new file mode 100644 index 0000000..0cbd799 --- /dev/null +++ b/aclang.m4 @@ -0,0 +1,2194 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Programming languages support. +#------------------------------------------------------------------------------ +# Copyright 2020-2021,2023 Thomas E. Dickey +# Copyright 2000, 2001 +# 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. +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_shiftn(2, $@))], + [AC_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_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. +m4_defun([_AC_LANG_ABBREV], +[_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)])]) + + + +# -------------------- # +# 1b. The C language. # +# -------------------- # + + +# AC_LANG(C) +# ---------- +# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. +m4_define([AC_LANG(C)], +[ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS "conftest.$ac_ext" >&AS_MESSAGE_LOG_FD' +ac_link='$CC -o "conftest$ac_exeext" $CFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +ac_main_return="return" +]) + + +# AC_LANG_C +# --------- +AU_DEFUN([AC_LANG_C], [AC_LANG(C)]) + + +# _AC_LANG_ABBREV(C) +# ------------------ +m4_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. +m4_define([AC_LANG(C++)], +[ac_ext=cc +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS "conftest.$ac_ext" >&AS_MESSAGE_LOG_FD' +ac_link='$CXX -o "conftest$ac_exeext" $CXXFLAGS $CPPFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +ac_main_return="return" +]) + + +# AC_LANG_CPLUSPLUS +# ----------------- +AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)]) + + +# _AC_LANG_ABBREV(C++) +# -------------------- +m4_define([_AC_LANG_ABBREV(C++)], [cxx]) + + +# ----------------------------- # +# 1d. The Fortran 77 language. # +# ----------------------------- # + + +# AC_LANG(Fortran 77) +# ------------------- +m4_define([AC_LANG(Fortran 77)], +[ac_ext=f +ac_compile='$F77 -c $FFLAGS "conftest.$ac_ext" >&AS_MESSAGE_LOG_FD' +ac_link='$F77 -o "conftest$ac_exeext" $FFLAGS $LDFLAGS "conftest.$ac_ext" $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_f77_compiler_gnu +]) + + +# AC_LANG_FORTRAN77 +# ----------------- +AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)]) + + +# _AC_LANG_ABBREV(Fortran 77) +# --------------------------- +m4_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. +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' 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 `conftest.val'. +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]" +m4_define([AC_LANG_SOURCE(C)], +[#line __oline__ "configure" +#include "confdefs.h" +$1]) + + +# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY]) +# -------------------------------------- +# If AC_F77_DUMMY_MAIN was run, then any C/C++ program might be linked +# against Fortran code, hence a dummy main might be needed. +m4_define([AC_LANG_PROGRAM(C)], +[$1 +m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS()])dnl +int +main (void) +{ +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. +m4_define([AC_LANG_CALL(C)], +[AC_LANG_PROGRAM([$1 +m4_if([$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 (void);])], [$2 ();])]) + + +# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION) +# ---------------------------------- +# This test used to merely assign f=$1 in main(), but that was optimized away +# by HP unbundled cc A.05.36 for ia64 under +O3, presumably because the program +# is about to exit. Conversely, the AIX linker optimizes an unused external +# declaration that initializes f=$1. Therefore, the test program has both an +# external initialization of f, as well as using f in a way that affects the +# exit status. +# +m4_define([AC_LANG_FUNC_LINK_TRY(C)], +[AC_LANG_PROGRAM( +[#define $1 autoconf_temporary +#include <limits.h> /* least-intrusive standard header which defines gcc2 __stub macros */ +#undef $1 + +#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 (void); +],[ +/* The GNU C library defines stubs 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) +#error found stub for $1 +#endif + + return $1 ();])]) + + +# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION) +# ------------------------------------------------- +m4_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'. +m4_define([AC_LANG_INT_SAVE(C)], +[AC_LANG_PROGRAM([m4_default([$1], [@%:@include <stdio.h>])], +[FILE *f = fopen ("conftest.val", "w"); +if (!f) + $ac_main_return (1); +fprintf (f, "%ld", (long)($2)); +fclose (f);])]) + + +# ----------------- # +# 2c. C++ sources. # +# ----------------- # + +# AC_LANG_SOURCE(C++)(BODY) +# ------------------------- +m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)]) + + +# AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY]) +# ---------------------------------------- +m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)]) + + +# AC_LANG_CALL(C++)(PROLOGUE, FUNCTION) +# ------------------------------------- +m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)]) + + +# AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION) +# ------------------------------------ +m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)]) + + +# AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION) +# --------------------------------------------------- +m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)]) + + +# AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION) +# ------------------------------------------- +m4_copy([AC_LANG_INT_SAVE(C)], [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? +m4_define([AC_LANG_SOURCE(Fortran 77)], +[$1]) + + +# AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY]) +# ----------------------------------------------- +# Yes, we discard the PROLOGUE. +m4_define([AC_LANG_PROGRAM(Fortran 77)], +[m4_ifval([$1], + [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl + program main +$2 + end]) + + +# AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION) +# -------------------------------------------- +# FIXME: This is a guess, help! +m4_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. 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 +# 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_COMPILER_EXEEXT_WORKS]) +AC_BEFORE([$0], [_AC_COMPILER_EXEEXT]) + +m4_define([_AC_COMPILER_EXEEXT_WORKS], +[cross_compiling=maybe +]) + +m4_define([_AC_COMPILER_EXEEXT], +[EXEEXT= +]) + +m4_define([AC_LINK_IFELSE], +[AC_FATAL([All the tests involving linking were disabled by $0])]) + +m4_divert_pop()dnl +])# AC_NO_EXECUTABLES + + + +# ----------------------------- # +# 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' + + +# 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. +# 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. +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([for _AC_LANG compiler default output]) +ac_link_default=`echo "$ac_link" | sed ['s/ -o *"conftest[^"]*"//']` +AS_IF([AC_TRY_EVAL(ac_link_default)], +[# Find the output, starting from the most likely. This scheme is +# not robust to junk in `.', hence go to wildcards (a.*) only as a last +# resort. +for ac_file in `ls a.exe conftest.exe 2>/dev/null; + ls a.out conftest 2>/dev/null; + ls a.* conftest.* 2>/dev/null`; do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;; + a.out ) # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` + # FIXME: I believe we export ac_cv_exeext for Libtool --akim. + export ac_cv_exeext + break;; + * ) break;; + esac +done], + [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD +cat "conftest.$ac_ext" >&AS_MESSAGE_LOG_FD +AC_MSG_ERROR([_AC_LANG compiler cannot create executables], 77)]) +ac_exeext=$ac_cv_exeext +AC_MSG_RESULT([$ac_file]) +])# _AC_COMPILER_EXEEXT_DEFAULT + + +# _AC_COMPILER_EXEEXT_WORKS +# ------------------------- +m4_define([_AC_COMPILER_EXEEXT_WORKS], +[# Check the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +AC_MSG_CHECKING([whether the _AC_LANG compiler works]) +# 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([./$ac_file]); then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + AC_MSG_ERROR([cannot run _AC_LANG compiled programs. +If you meant to cross compile, use `--host'.]) + fi + fi +fi +AC_MSG_RESULT([yes]) +])# _AC_COMPILER_EXEEXT_WORKS + + +# _AC_COMPILER_EXEEXT_CROSS +# ------------------------- +m4_define([_AC_COMPILER_EXEEXT_CROSS], +[# Check 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]) +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 executable suffix]) +AS_IF([AC_TRY_EVAL(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 `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` + export ac_cv_exeext + break;; + * ) break;; + esac +done], + [AC_MSG_ERROR([cannot compute EXEEXT: cannot compile and link])]) +rm -f "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 no to destroy user files. +# +# Must be run before _AC_COMPILER_OBJEXT because _AC_COMPILER_EXEEXT_DEFAULT +# checks whether the compiler works. +m4_define([_AC_COMPILER_EXEEXT], +[AC_LANG_CONFTEST([AC_LANG_PROGRAM()]) +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.exe" +_AC_COMPILER_EXEEXT_DEFAULT +_AC_COMPILER_EXEEXT_WORKS +rm -f a.out a.exe "conftest$ac_cv_exeext" +ac_clean_files=$ac_clean_files_save +_AC_COMPILER_EXEEXT_CROSS +_AC_COMPILER_EXEEXT_O +rm -f "conftest.$ac_ext" +AC_SUBST([EXEEXT], [$ac_cv_exeext])dnl +ac_exeext=$EXEEXT +])# _AC_COMPILER_EXEEXT + + +# _AC_COMPILER_OBJEXT +# ------------------- +# Check the object extension used by the compiler: typically `.o' or +# `.obj'. If this is called, some other behaviour 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 object suffix], ac_cv_objext, +[AC_LANG_CONFTEST([AC_LANG_PROGRAM()]) +rm -f conftest.o conftest.obj +AS_IF([AC_TRY_EVAL(ac_compile)], +[for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.map | *.inf ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done], + [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD +cat "conftest.$ac_ext" >&AS_MESSAGE_LOG_FD +AC_MSG_ERROR([cannot compute OBJEXT: cannot compile])]) +rm -f "conftest.$ac_cv_objext" "conftest.$ac_ext"]) +AC_SUBST([OBJEXT], [$ac_cv_objext])dnl +ac_objext=$OBJEXT +])# _AC_COMPILER_OBJEXT + + +# -------------------- # +# 3b. The C compiler. # +# -------------------- # + + +# _AC_ARG_VAR_CPPFLAGS +# -------------------- +# Document and register CPPFLAGS, which is used by +# AC_PROG_{CC, CPP, CXX, CXXCPP}. +AC_DEFUN([_AC_ARG_VAR_CPPFLAGS], +[AC_ARG_VAR([CPPFLAGS], + [C/C++ preprocessor flags, e.g. -I<include dir> if you have + headers in a nonstandard directory <include dir>])]) + + +# _AC_ARG_VAR_LDFLAGS +# ------------------- +# Document and register LDFLAGS, which is used by +# AC_PROG_{CC, CXX, F77}. +AC_DEFUN([_AC_ARG_VAR_LDFLAGS], +[AC_ARG_VAR([LDFLAGS], + [linker flags, e.g. -L<lib dir> if you have libraries in a + nonstandard directory <lib dir>])]) + + + +# AC_LANG_PREPROC(C) +# ------------------- +# Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(C)], +[AC_REQUIRE([AC_PROG_CPP])]) + + +# _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT) +# ----------------------------------------------- +# 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_IFELSE], +[ac_preproc_ok=false +for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes +do + # 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_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <assert.h> + Syntax error]])], + [], + [# Broken: fails on valid input. +continue]) + + # OK, works on sane cases. Now check whether non-existent headers + # can be detected and how. + _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])], + [# Broken: success on invalid input. +continue], + [# Passes both tests. +ac_preproc_ok=: +break]) + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.err "conftest.$ac_ext" +AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE + + +# AC_PROG_CPP +# ----------- +# Find a working C preprocessor. +# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency +# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC. +AC_DEFUN([AC_PROG_CPP], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_ARG_VAR([CPP], [C preprocessor])dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_LANG_PUSH(C)dnl +AC_MSG_CHECKING([how to run the C preprocessor]) +# 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 -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + _AC_PROG_PREPROC_WORKS_IFELSE([break]) + done + ac_cv_prog_CPP=$CPP + ])dnl + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +AC_MSG_RESULT([$CPP]) +_AC_PROG_PREPROC_WORKS_IFELSE([], + [AC_MSG_ERROR([C preprocessor "$CPP" fails sanity check])]) +AC_SUBST(CPP)dnl +AC_LANG_POP(C)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_REQUIRE([AC_PROG_CC])]) + + +# ac_cv_prog_gcc +# -------------- +# We used to name the cache variable this way. +AU_DEFUN([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_LANG_PUSH(C)dnl +AC_ARG_VAR([CC], [C compiler command])dnl +AC_ARG_VAR([CFLAGS], [C compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +m4_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]) + +# Provide some information about the compiler. +echo "$as_me:__oline__:" \ + "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD +ac_compiler=`set X $ac_compile; echo "$[2]"` +_AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD]) +_AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD]) +_AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD]) + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +GCC=`test $ac_compiler_gnu = yes && echo yes` +_AC_PROG_CC_G +# Some people use a C++ compiler to compile C. Since we use `exit', +# in C++ we need to declare it. In case someone uses the same compiler +# for both compiling C and C++ we need to have the C++ compiler decide +# the declaration of exit, since it's the most demanding environment. +_AC_COMPILE_IFELSE([@%:@ifndef __cplusplus + choke me +@%:@endif], + [_AC_PROG_CXX_EXIT_DECLARATION]) +AC_LANG_POP(C)dnl +])# 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. +m4_define([_AC_PROG_CC_G], +[ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +CFLAGS="-g" +AC_CACHE_CHECK(whether $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], +[if test $ac_cv_c_compiler_gnu = yes; then + AC_CACHE_CHECK(whether $CC needs -traditional, + ac_cv_prog_gcc_traditional, +[ ac_pattern="Autoconf.*'x'" + AC_EGREP_CPP($ac_pattern, [#include <sgtty.h> +int 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> +int 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 -c "conftest.$ac_ext" -o "conftest.$ac_objext" >&AS_MESSAGE_LOG_FD' +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" >&AS_MESSAGE_LOG_FD); then + ac_try='cc -c "conftest.$ac_ext" -o "conftest.$ac_objext" >&AS_MESSAGE_LOG_FD' + 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 -rf 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_LANG_PREPROC(C++) +# --------------------- +# Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(C++)], +[AC_REQUIRE([AC_PROG_CXXCPP])]) + + +# AC_PROG_CXXCPP +# -------------- +# Find a working C++ preprocessor. +# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency +# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX. +AC_DEFUN([AC_PROG_CXXCPP], +[AC_REQUIRE([AC_PROG_CXX])dnl +AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_LANG_PUSH(C++)dnl +AC_MSG_CHECKING([how to run the C++ preprocessor]) +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 -E" "/lib/cpp" + do + _AC_PROG_PREPROC_WORKS_IFELSE([break]) + done + ac_cv_prog_CXXCPP=$CXXCPP + ])dnl + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +AC_MSG_RESULT([$CXXCPP]) +_AC_PROG_PREPROC_WORKS_IFELSE([], + [AC_MSG_ERROR([C++ preprocessor "$CXXCPP" fails sanity check])]) +AC_SUBST(CXXCPP)dnl +AC_LANG_POP(C++)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_REQUIRE([AC_PROG_CXX])]) + + +# ac_cv_prog_gxx +# -------------- +# We used to name the cache variable this way. +AU_DEFUN([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. +# FCC Fujitsu C++ compiler +# 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_LANG_PUSH(C++)dnl +AC_ARG_VAR([CXX], [C++ compiler command])dnl +AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_CHECK_TOOLS(CXX, + [$CCC m4_default([$1], + [g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC])], + g++) + +# Provide some information about the compiler. +echo "$as_me:__oline__:" \ + "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD +ac_compiler=`set X $ac_compile; echo $[2]` +_AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD]) +_AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD]) +_AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD]) + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +GXX=`test $ac_compiler_gnu = yes && echo yes` +_AC_PROG_CXX_G +_AC_PROG_CXX_EXIT_DECLARATION +AC_LANG_POP(C++)dnl +])# 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. +m4_define([_AC_PROG_CXX_G], +[ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +CXXFLAGS="-g" +AC_CACHE_CHECK(whether $CXX 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 + + +# _AC_PROG_CXX_EXIT_DECLARATION +# ----------------------------- +# Find a valid prototype for exit and declare it in confdefs.h. +m4_define([_AC_PROG_CXX_EXIT_DECLARATION], +[for ac_declaration in \ + ''\ + '#include <stdlib.h>' \ + 'extern "C" void std::exit (int) throw (); using std::exit;' \ + 'extern "C" void std::exit (int); using std::exit;' \ + 'extern "C" void exit (int) throw ();' \ + 'extern "C" void exit (int);' \ + 'void exit (int);' +do + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([@%:@include <stdlib.h> +$ac_declaration], + [exit (42);])], + [], + [continue]) + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$ac_declaration], + [exit (42);])], + [break]) +done +rm -rf conftest* +if test -n "$ac_declaration"; then + echo '#ifdef __cplusplus' >>confdefs.h + echo "$ac_declaration" >>confdefs.h + echo '#endif' >>confdefs.h +fi +])# _AC_PROG_CXX_EXIT_DECLARATION + + +# ----------------------------- # +# 3d. The Fortran 77 compiler. # +# ----------------------------- # + + +# AC_LANG_PREPROC(Fortran 77) +# --------------------------- +# Find the Fortran 77 preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(Fortran 77)], +[m4_warn([syntax], + [$0: No preprocessor defined for ]_AC_LANG)]) + + +# 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_REQUIRE([AC_PROG_F77])]) + + +# ac_cv_prog_g77 +# -------------- +# We used to name the cache variable this way. +AU_DEFUN([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-compatible with Fortran 77, but +# `f95' is worth trying. +# +# Compilers are ordered by +# 1. F77, F90, F95 +# 2. Good/tested native compilers, bad/untested native compilers +# 3. Wrappers around f2c go last. +# +# `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. On some Cray systems, fort77 is a native compiler. +# cf77 and cft77 are (older) Cray F77 compilers. +# frt is the Fujitsu F77 compiler. +# pgf77 and pgf90 are the Portland Group F77 and F90 compilers. +# xlf/xlf90/xlf95 are IBM (AIX) F77/F90/F95 compilers. +# lf95 is the Lahey-Fujitsu compiler. +# fl32 is the Microsoft Fortran "PowerStation" compiler. +# af77 is the Apogee F77 compiler for Intergraph hardware running CLIX. +# epcf90 is the "Edinburgh Portable Compiler" F90. +# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha. +AC_DEFUN([AC_PROG_F77], +[AC_LANG_PUSH(Fortran 77)dnl +AC_ARG_VAR([F77], [Fortran 77 compiler command])dnl +AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +AC_CHECK_TOOLS(F77, + [m4_default([$1], + [g77 f77 xlf cf77 cft77 frt pgf77 fl32 af77 fort77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 lf95 g95])]) + +# Provide some information about the compiler. +echo "$as_me:__oline__:" \ + "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD +ac_compiler=`set X $ac_compile; echo $[2]` +_AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD]) +_AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD]) +_AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD]) + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +# If we don't use `.F' as extension, the preprocessor is not run on the +# input file. +ac_save_ext=$ac_ext +ac_ext=F +_AC_LANG_COMPILER_GNU +ac_ext=$ac_save_ext +G77=`test $ac_compiler_gnu = yes && echo yes` +_AC_PROG_F77_G +AC_LANG_POP(Fortran 77)dnl +])# 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. +m4_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 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" >&AS_MESSAGE_LOG_FD' +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 -rf conftest*]) +if test $ac_cv_prog_f77_c_o = no; 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 option to accept ANSI C]) +AC_CACHE_VAL(ac_cv_prog_cc_stdc, +[ac_cv_prog_cc_stdc=no +ac_save_CC=$CC +AC_LANG_CONFTEST([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 (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];]])]) +# 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_cv_prog_cc_stdc=$ac_arg +break]) +done +rm -f "conftest.$ac_ext" "conftest.$ac_objext" +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_C_CROSS +# ---------- +# Has been merged into AC_PROG_CC. +AU_DEFUN([AC_C_CROSS], []) + + +# 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 (void) +{ + /* 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. */ + $ac_main_return (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 (void) +{ + /* Are we little or big endian? From Harbison&Steele. */ + union + { + long l; + char c[sizeof (long)]; + } u; + u.l = 1; + $ac_main_return (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 +static $ac_kw int static_foo (void) {return 0; } +$ac_kw int foo (void) {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; (void)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}; (void)zero; + /* 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; + (void)s; + } + { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ + int x[] = {25, 17}; + const int *foo = &x[0]; + ++foo; + (void)foo; + } + { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ + typedef const int *iptr; + iptr p = 0; + ++p; + (void)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; + (void)foo; + } +#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_CACHE_CHECK([for preprocessor stringizing operator], + [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_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_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. Fortran 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)dnl + +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 $as_me:__oline__: \"$ac_link\") >&AS_MESSAGE_LOG_FD +ac_f77_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | grep -v 'Driving:'` +echo "$ac_f77_v_output" >&AS_MESSAGE_LOG_FD +FFLAGS=$ac_save_FFLAGS + +rm -rf conftest* +AC_LANG_POP(Fortran 77)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, Fujitsu: -###) +AC_DEFUN([_AC_PROG_F77_V], +[AC_CACHE_CHECK([how to get verbose linking output from $F77], + [ac_cv_prog_f77_v], +[AC_LANG_ASSERT(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_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_LANG_PUSH(Fortran 77)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_LANG_POP(Fortran 77)dnl +])# AC_F77_LIBRARY_LDFLAGS + + +# AC_F77_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ----------------------------------------------------------- +# +# Detect name of dummy main routine required by the Fortran libraries, +# (if any) and define F77_DUMMY_MAIN to this name (which should be +# used for a dummy declaration, if it is defined). On some systems, +# linking a C program to the Fortran library does not work unless you +# supply a dummy function called something like MAIN__. +# +# Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C +# program with the F77 libs is found; default to exiting with an error +# message. Execute ACTION-IF-FOUND if a dummy routine name is needed +# and found or if it is not needed (default to defining F77_DUMMY_MAIN +# when needed). +# +# What is technically happening is that the Fortran libraries provide +# their own main() function, which usually initializes Fortran I/O and +# similar stuff, and then calls MAIN__, which is the entry point of +# your program. Usually, a C program will override this with its own +# main() routine, but the linker sometimes complain if you don't +# provide a dummy (never-called) MAIN__ routine anyway. +# +# Of course, programs that want to allow Fortran subroutines to do +# I/O, etcetera, should call their main routine MAIN__() (or whatever) +# instead of main(). A separate autoconf test (AC_F77_MAIN) checks +# for the routine to use in this case (since the semantics of the test +# are slightly different). To link to e.g. purely numerical +# libraries, this is normally not necessary, however, and most C/C++ +# programs are reluctant to turn over so much control to Fortran. =) +# +# The name variants we check for are (in order): +# MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional) +# MAIN_, __main (SunOS) +# MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too) +AC_DEFUN([AC_F77_DUMMY_MAIN], +[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl +m4_define([_AC_LANG_PROGRAM_C_F77_HOOKS], +[#ifdef F77_DUMMY_MAIN +# ifdef __cplusplus + extern "C" +# endif + int F77_DUMMY_MAIN() { return 1; } +#endif +]) +AC_CACHE_CHECK([for dummy main to link with Fortran 77 libraries], + ac_cv_f77_dummy_main, +[AC_LANG_PUSH(C)dnl + ac_f77_dm_save_LIBS=$LIBS + LIBS="$LIBS $FLIBS" + + # First, try linking without a dummy main: + AC_TRY_LINK([], [], + ac_cv_f77_dummy_main=none, + ac_cv_f77_dummy_main=unknown) + + if test $ac_cv_f77_dummy_main = unknown; then + for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do + AC_TRY_LINK([@%:@define F77_DUMMY_MAIN $ac_func], + [], [ac_cv_f77_dummy_main=$ac_func; break]) + done + fi + rm -rf conftest* + LIBS=$ac_f77_dm_save_LIBS + AC_LANG_POP(C)dnl +]) +F77_DUMMY_MAIN=$ac_cv_f77_dummy_main +AS_IF([test "$F77_DUMMY_MAIN" != unknown], + [m4_default([$1], +[if test $F77_DUMMY_MAIN != none; then + AC_DEFINE_UNQUOTED([F77_DUMMY_MAIN], $F77_DUMMY_MAIN, + [Define to dummy `main' function (if any) required to + link to the Fortran 77 libraries.]) +fi])], + [m4_default([$2], + [AC_MSG_ERROR([Linking to Fortran libraries from C fails.])])]) +])# AC_F77_DUMMY_MAIN + + +# AC_F77_MAIN +# ----------- +# Define F77_MAIN to name of alternate main() function for use with +# the Fortran libraries. (Typically, the libraries may define their +# own main() to initialize I/O, etcetera, that then call your own +# routine called MAIN__ or whatever.) See AC_F77_DUMMY_MAIN, above. +# If no such alternate name is found, just define F77_MAIN to main. +# +AC_DEFUN([AC_F77_MAIN], +[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl +AC_CACHE_CHECK([for alternate main to link with Fortran 77 libraries], + ac_cv_f77_main, +[AC_LANG_PUSH(C)dnl + ac_f77_m_save_LIBS=$LIBS + LIBS="$LIBS $FLIBS" + ac_cv_f77_main="main" # default entry point name + + for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do + AC_TRY_LINK([#undef F77_DUMMY_MAIN +@%:@define main $ac_func], [], [ac_cv_f77_main=$ac_func; break]) + done + rm -rf conftest* + LIBS=$ac_f77_m_save_LIBS + AC_LANG_POP(C)dnl +]) +AC_DEFINE_UNQUOTED([F77_MAIN], $ac_cv_f77_main, + [Define to alternate name for `main' routine that is + called from a `main' in the Fortran libraries.]) +])# AC_F77_MAIN + + +# _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 Fortran 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_F77_LIBRARY_LDFLAGS])dnl +AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl +AC_CACHE_CHECK([for Fortran 77 name-mangling scheme], + ac_cv_f77_mangling, +[AC_LANG_PUSH(Fortran 77)dnl +AC_COMPILE_IFELSE( +[ subroutine foobar() + return + end + subroutine foo_bar() + return + end], +[mv "conftest.$ac_objext" "cf77_test.$ac_objext" + + AC_LANG_PUSH(C)dnl + + ac_save_LIBS=$LIBS + LIBS="cf77_test.$ac_objext $LIBS $FLIBS" + + 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(C)dnl + rm -rf cf77_test* conftest*]) +AC_LANG_POP(Fortran 77)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 +m4_if(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 |