Created
January 10, 2014 17:26
-
-
Save agordon/8358592 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# This file is part of Autoconf. -*- Autoconf -*- | |
# Fortran languages support. | |
# Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free | |
# Software Foundation, Inc. | |
# This file is part of Autoconf. This program is free | |
# software; you can redistribute it and/or modify it under the | |
# terms of the GNU General Public License as published by the | |
# Free Software Foundation, either version 3 of the License, or | |
# (at your option) any later version. | |
# | |
# This program is distributed in the hope that it will be useful, | |
# but WITHOUT ANY WARRANTY; without even the implied warranty of | |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
# GNU General Public License for more details. | |
# | |
# Under Section 7 of GPL version 3, you are granted additional | |
# permissions described in the Autoconf Configure Script Exception, | |
# version 3.0, as published by the Free Software Foundation. | |
# | |
# You should have received a copy of the GNU General Public License | |
# and a copy of the Autoconf Configure Script Exception along with | |
# this program; see the files COPYINGv3 and COPYING.EXCEPTION | |
# respectively. If not, see <http://www.gnu.org/licenses/>. | |
# Written by David MacKenzie, with help from | |
# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, | |
# Roland McGrath, Noah Friedman, david d zuhn, and many others. | |
# Table of Contents: | |
# | |
# Preamble | |
# | |
# 0. Utility macros | |
# | |
# 1. Language selection | |
# and routines to produce programs in a given language. | |
# | |
# 2. Producing programs in a given language. | |
# | |
# 3. Looking for a compiler | |
# And possibly the associated preprocessor. | |
# | |
# 4. Compilers' characteristics. | |
## ---------- ## | |
## Preamble. ## | |
## ---------- ## | |
# Fortran vs. Fortran 77: | |
# This file contains macros for both "Fortran 77" and "Fortran", where | |
# the former is the "classic" autoconf Fortran interface and is intended | |
# for legacy F77 codes, while the latter is intended to support newer Fortran | |
# dialects. Fortran 77 uses environment variables F77, FFLAGS, and FLIBS, | |
# while Fortran uses FC, FCFLAGS, and FCLIBS. For each user-callable AC_* | |
# macro, there is generally both an F77 and an FC version, where both versions | |
# share the same _AC_*_FC_* backend. This backend macro requires that | |
# the appropriate language be AC_LANG_PUSH'ed, and uses _AC_LANG_ABBREV and | |
# _AC_LANG_PREFIX in order to name cache and environment variables, etc. | |
## ------------------- ## | |
## 0. Utility macros. ## | |
## ------------------- ## | |
# _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) | |
# --------------------------------------------------------------------------- | |
# | |
# Processing the elements of a list is tedious in shell programming, | |
# as lists tend to be implemented as space delimited strings. | |
# | |
# This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND | |
# if ELEMENT is a member of LIST, otherwise it executes | |
# ACTION-IF-NOT-FOUND. | |
AC_DEFUN([_AC_LIST_MEMBER_IF], | |
dnl Do some sanity checking of the arguments. | |
[m4_if([$1], , [m4_fatal([$0: missing argument 1])], | |
[$2], , [m4_fatal([$0: missing argument 2])])]dnl | |
[ ac_exists=false | |
for ac_i in $2; do | |
if test x"$1" = x"$ac_i"; then | |
ac_exists=true | |
break | |
fi | |
done | |
AS_IF([test x"$ac_exists" = xtrue], [$3], [$4])[]dnl | |
])# _AC_LIST_MEMBER_IF | |
# _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE) | |
# ------------------------------------------------- | |
# | |
# Specifying options to the compiler (whether it be the C, C++ or | |
# Fortran 77 compiler) that are meant for the linker is compiler | |
# dependent. This macro lets you give options to the compiler that | |
# are meant for the linker in a portable, compiler-independent way. | |
# | |
# This macro take two arguments, a list of linker options that the | |
# compiler should pass to the linker (LINKER-OPTIONS) and the name of | |
# a shell variable (SHELL-VARIABLE). The list of linker options are | |
# appended to the shell variable in a compiler-dependent way. | |
# | |
# For example, if the selected language is C, then this: | |
# | |
# _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS) | |
# | |
# will expand into this if the selected C compiler is gcc: | |
# | |
# foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo" | |
# | |
# otherwise, it will expand into this: | |
# | |
# foo_LDFLAGS"-R /usr/local/lib/foo" | |
# | |
# You are encouraged to add support for compilers that this macro | |
# doesn't currently support. | |
# FIXME: Get rid of this macro. | |
AC_DEFUN([_AC_LINKER_OPTION], | |
[if test "$ac_compiler_gnu" = yes; then | |
for ac_link_opt in $1; do | |
$2="[$]$2 -Xlinker $ac_link_opt" | |
done | |
else | |
$2="[$]$2 $1" | |
fi[]dnl | |
])# _AC_LINKER_OPTION | |
## ------------------------ ## | |
## 1a. Language selection. ## | |
## ------------------------ ## | |
# AC_LANG(Fortran 77) | |
# ------------------- | |
AC_LANG_DEFINE([Fortran 77], [f77], [F], [F77], [], | |
[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_FORTRAN_ASSERT | |
# ------------------ | |
# Current language must be Fortran or Fortran 77. | |
m4_defun([_AC_FORTRAN_ASSERT], | |
[m4_if(_AC_LANG, [Fortran], [], | |
[m4_if(_AC_LANG, [Fortran 77], [], | |
[m4_fatal([$0: current language is not Fortran: ] _AC_LANG)])])]) | |
# _AC_FC | |
# ------ | |
# Return F77 or FC, depending upon the language. | |
AC_DEFUN([_AC_FC], | |
[_AC_FORTRAN_ASSERT()dnl | |
AC_LANG_CASE([Fortran 77], [F77], | |
[Fortran], [FC])]) | |
## ----------------------- ## | |
## 2. Producing programs. ## | |
## ----------------------- ## | |
# 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_IO_PROGRAM(Fortran 77) | |
# ------------------------------- | |
# Produce source that performs I/O. | |
m4_define([_AC_LANG_IO_PROGRAM(Fortran 77)], | |
[AC_LANG_PROGRAM([], | |
[dnl | |
open(unit=9,file='conftest.out') | |
close(unit=9) | |
])]) | |
# 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])]) | |
# AC_LANG_FUNC_LINK_TRY(Fortran 77)(FUNCTION) | |
# ------------------------------------------- | |
m4_define([AC_LANG_FUNC_LINK_TRY(Fortran 77)], | |
[AC_LANG_PROGRAM([], | |
[ call $1])]) | |
## ------------------------ ## | |
## 1b. Language selection. ## | |
## ------------------------ ## | |
# AC_LANG(Fortran) | |
# ---------------- | |
AC_LANG_DEFINE([Fortran], [fc], [FC], [FC], [Fortran 77], | |
[ac_ext=${ac_fc_srcext-f} | |
ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&AS_MESSAGE_LOG_FD' | |
ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' | |
ac_compiler_gnu=$ac_cv_fc_compiler_gnu | |
]) | |
## -------------------------------------------- ## | |
## 3. Looking for Compilers and Preprocessors. ## | |
## -------------------------------------------- ## | |
# 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_PREPROC(Fortran) | |
# --------------------------- | |
# Find the Fortran preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. | |
AC_DEFUN([AC_LANG_PREPROC(Fortran)], | |
[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_LANG_COMPILER(Fortran) | |
# ---------------------------- | |
# Find the Fortran compiler. Must be AC_DEFUN'd to be | |
# AC_REQUIRE'able. | |
AC_DEFUN([AC_LANG_COMPILER(Fortran)], | |
[AC_REQUIRE([AC_PROG_FC])]) | |
# 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_FC_DIALECT_YEAR([DIALECT]) | |
# ------------------------------ | |
# Given a Fortran DIALECT, which is Fortran [YY]YY or simply [YY]YY, | |
# convert to a 4-digit year. The dialect must be one of Fortran 77, | |
# 90, 95, or 2000, currently. If DIALECT is simply Fortran or the | |
# empty string, returns the empty string. | |
AC_DEFUN([_AC_FC_DIALECT_YEAR], | |
[m4_case(m4_bpatsubsts(m4_tolower([$1]), [fortran],[], [ *],[]), | |
[77],[1977], [1977],[1977], | |
[90],[1990], [1990],[1990], | |
[95],[1995], [1995],[1995], | |
[2000],[2000], | |
[],[], | |
[m4_fatal([unknown Fortran dialect])])]) | |
# _AC_PROG_FC([DIALECT], [COMPILERS...]) | |
# -------------------------------------- | |
# DIALECT is a Fortran dialect, given by Fortran [YY]YY or simply [YY]YY, | |
# and must be one of those supported by _AC_FC_DIALECT_YEAR | |
# | |
# If DIALECT is supplied, then we search for compilers of that dialect | |
# first, and then later dialects. Otherwise, we search for compilers | |
# of the newest dialect first, and then earlier dialects in increasing age. | |
# This search order is necessarily imperfect because the dialect cannot | |
# always be inferred from the compiler name. | |
# | |
# Known compilers: | |
# f77/f90/f95: generic compiler names | |
# g77: GNU Fortran 77 compiler | |
# gfortran: GNU Fortran 95+ compiler (released in gcc 4.0) | |
# g95: original gcc-based f95 compiler (gfortran is a fork) | |
# ftn: native Fortran 95 compiler on Cray X1 | |
# cf77: native F77 compiler under older Crays (prefer over fort77) | |
# fort77: native F77 compiler under HP-UX (and some older Crays) | |
# frt: Fujitsu F77 compiler | |
# pgf77/pgf90/pghpf/pgf95: Portland Group F77/F90/F95 compilers | |
# xlf/xlf90/xlf95: IBM (AIX) F77/F90/F95 compilers | |
# Prefer xlf9x to the generic names because they do not reject file | |
# with extension `.f'. | |
# lf95: Lahey-Fujitsu F95 compiler | |
# fl32: Microsoft Fortran 77 "PowerStation" compiler | |
# af77: Apogee F77 compiler for Intergraph hardware running CLIX | |
# epcf90: "Edinburgh Portable Compiler" F90 | |
# fort: Compaq (now HP) Fortran 90/95 compiler for Tru64 and Linux/Alpha | |
# ifort, previously ifc: Intel Fortran 95 compiler for Linux/x86 | |
# efc: Intel Fortran 95 compiler for IA64 | |
m4_define([_AC_F95_FC], [gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn]) | |
m4_define([_AC_F90_FC], [xlf90 f90 pgf90 pghpf epcf90]) | |
m4_define([_AC_F77_FC], [g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77]) | |
AC_DEFUN([_AC_PROG_FC], | |
[_AC_FORTRAN_ASSERT()dnl | |
AC_CHECK_TOOLS([]_AC_FC[], | |
m4_default([$2], | |
m4_case(_AC_FC_DIALECT_YEAR([$1]), | |
[1995], [_AC_F95_FC], | |
[1990], [_AC_F90_FC _AC_F95_FC], | |
[1977], [_AC_F77_FC _AC_F90_FC _AC_F95_FC], | |
[_AC_F95_FC _AC_F90_FC _AC_F77_FC]))) | |
# Provide some information about the compiler. | |
_AS_ECHO_LOG([checking for _AC_LANG compiler version]) | |
set X $ac_compile | |
ac_compiler=$[2] | |
for ac_option in --version -v -V -qversion; do | |
_AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) | |
done | |
rm -f a.out | |
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. (Note that this only needs to work for GNU compilers.) | |
ac_save_ext=$ac_ext | |
ac_ext=F | |
_AC_LANG_COMPILER_GNU | |
ac_ext=$ac_save_ext | |
_AC_PROG_FC_G | |
])# _AC_PROG_FC | |
# AC_PROG_F77([COMPILERS...]) | |
# --------------------------- | |
# COMPILERS is a space separated list of Fortran 77 compilers to search | |
# for. See also _AC_PROG_FC. | |
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_ARG_VAR_LIBS()dnl | |
_AC_PROG_FC([Fortran 77], [$1]) | |
if test $ac_compiler_gnu = yes; then | |
G77=yes | |
else | |
G77= | |
fi | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_PROG_F77 | |
# AC_PROG_FC([COMPILERS...], [DIALECT]) | |
# ------------------------------------- | |
# COMPILERS is a space separated list of Fortran 77 compilers to search | |
# for, and [DIALECT] is an optional dialect. See also _AC_PROG_FC. | |
AC_DEFUN([AC_PROG_FC], | |
[AC_LANG_PUSH(Fortran)dnl | |
AC_ARG_VAR([FC], [Fortran compiler command])dnl | |
AC_ARG_VAR([FCFLAGS], [Fortran compiler flags])dnl | |
_AC_ARG_VAR_LDFLAGS()dnl | |
_AC_ARG_VAR_LIBS()dnl | |
_AC_PROG_FC([$2], [$1]) | |
AC_LANG_POP(Fortran)dnl | |
])# AC_PROG_FC | |
# _AC_PROG_FC_G | |
# ------------- | |
# Check whether -g works, even if F[C]FLAGS is set, in case the package | |
# plays around with F[C]FLAGS (such as to build both debugging and normal | |
# versions of a library), tasteless as that idea is. | |
m4_define([_AC_PROG_FC_G], | |
[_AC_FORTRAN_ASSERT()dnl | |
ac_test_[]_AC_LANG_PREFIX[]FLAGS=${[]_AC_LANG_PREFIX[]FLAGS+set} | |
ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS | |
_AC_LANG_PREFIX[]FLAGS= | |
AC_CACHE_CHECK(whether $[]_AC_FC[] accepts -g, ac_cv_prog_[]_AC_LANG_ABBREV[]_g, | |
[_AC_LANG_PREFIX[]FLAGS=-g | |
_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], | |
[ac_cv_prog_[]_AC_LANG_ABBREV[]_g=yes], | |
[ac_cv_prog_[]_AC_LANG_ABBREV[]_g=no]) | |
]) | |
if test "$ac_test_[]_AC_LANG_PREFIX[]FLAGS" = set; then | |
_AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS | |
elif test $ac_cv_prog_[]_AC_LANG_ABBREV[]_g = yes; then | |
if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu" = xyes; then | |
_AC_LANG_PREFIX[]FLAGS="-g -O2" | |
else | |
_AC_LANG_PREFIX[]FLAGS="-g" | |
fi | |
else | |
if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu" = xyes; then | |
_AC_LANG_PREFIX[]FLAGS="-O2" | |
else | |
_AC_LANG_PREFIX[]FLAGS= | |
fi | |
fi[]dnl | |
])# _AC_PROG_FC_G | |
# _AC_PROG_FC_C_O | |
# --------------- | |
# Test if the Fortran compiler accepts the options `-c' and `-o' | |
# simultaneously, and define `[F77/FC]_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. | |
# | |
# FIXME: it seems like we could merge the C/C++/Fortran versions of this. | |
AC_DEFUN([_AC_PROG_FC_C_O], | |
[_AC_FORTRAN_ASSERT()dnl | |
AC_CACHE_CHECK([whether $[]_AC_FC[] understands -c and -o together], | |
[ac_cv_prog_[]_AC_LANG_ABBREV[]_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='$[]_AC_FC[] $[]_AC_LANG_PREFIX[]FLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' | |
rm -f conftest2.* | |
if _AC_DO_VAR(ac_try) && | |
test -f conftest2.$ac_objext && | |
_AC_DO_VAR(ac_try); then | |
ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o=yes | |
else | |
ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o=no | |
fi | |
rm -f conftest*]) | |
if test $ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o = no; then | |
AC_DEFINE([]_AC_FC[]_NO_MINUS_C_MINUS_O, 1, | |
[Define to 1 if your Fortran compiler doesn't accept | |
-c and -o together.]) | |
fi | |
])# _AC_PROG_FC_C_O | |
# AC_PROG_F77_C_O | |
# --------------- | |
AC_DEFUN([AC_PROG_F77_C_O], | |
[AC_REQUIRE([AC_PROG_F77])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
_AC_PROG_FC_C_O | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_PROG_F77_C_O | |
# AC_PROG_FC_C_O | |
# --------------- | |
AC_DEFUN([AC_PROG_FC_C_O], | |
[AC_REQUIRE([AC_PROG_FC])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
_AC_PROG_FC_C_O | |
AC_LANG_POP(Fortran)dnl | |
])# AC_PROG_FC_C_O | |
## ------------------------------- ## | |
## 4. Compilers' characteristics. ## | |
## ------------------------------- ## | |
# _AC_PROG_FC_V_OUTPUT([FLAG = $ac_cv_prog_{f77/fc}_v]) | |
# ------------------------------------------------- | |
# Link a trivial Fortran program, compiling with a verbose output FLAG | |
# (whose default value, $ac_cv_prog_{f77/fc}_v, is computed by | |
# _AC_PROG_FC_V), and return the output in $ac_{f77/fc}_v_output. This | |
# output is processed in the way expected by _AC_FC_LIBRARY_LDFLAGS, | |
# so that any link flags that are echoed by the compiler appear as | |
# space-separated items. | |
AC_DEFUN([_AC_PROG_FC_V_OUTPUT], | |
[_AC_FORTRAN_ASSERT()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 compiler in order to get | |
# "verbose" output that we can then parse for the Fortran linker | |
# flags. | |
ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS | |
_AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS m4_default([$1], [$ac_cv_prog_[]_AC_LANG_ABBREV[]_v])" | |
eval "set x $ac_link" | |
shift | |
_AS_ECHO_LOG([$[*]]) | |
# gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH, | |
# LIBRARY_PATH; skip all such settings. | |
ac_[]_AC_LANG_ABBREV[]_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | | |
grep -v 'Driving:' | grep -v "^[[_$as_cr_Letters]][[_$as_cr_alnum]]*="` | |
AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) >&AS_MESSAGE_LOG_FD | |
_AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS | |
rm -rf conftest* | |
# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where | |
# /foo, /bar, and /baz are search directories for the Fortran linker. | |
# Here, we change these into -L/foo -L/bar -L/baz (and put it first): | |
ac_[]_AC_LANG_ABBREV[]_v_output="`echo $ac_[]_AC_LANG_ABBREV[]_v_output | | |
grep 'LPATH is:' | | |
sed 's|.*LPATH is\(: *[[^ ]]*\).*|\1|;s|: */| -L/|g'` $ac_[]_AC_LANG_ABBREV[]_v_output" | |
# FIXME: we keep getting bitten by quoted arguments; a more general fix | |
# that detects unbalanced quotes in FLIBS should be implemented | |
# and (ugh) tested at some point. | |
case $ac_[]_AC_LANG_ABBREV[]_v_output in | |
# If we are using xlf then replace all the commas with spaces. | |
*xlfentry*) | |
ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed 's/,/ /g'` ;; | |
# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted | |
# $LIBS confuse us, and the libraries appear later in the output anyway). | |
*mGLOB_options_string*) | |
ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed 's/"-mGLOB[[^"]]*"/ /g'` ;; | |
# Portland Group compiler has singly- or doubly-quoted -cmdline argument | |
# Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4. | |
# Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2". | |
*-cmdline\ * | *-ignore\ * | *-def\ *) | |
ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed "\ | |
s/-cmdline *'[[^']]*'/ /g; s/-cmdline *\"[[^\"]]*\"/ /g | |
s/-ignore *'[[^']]*'/ /g; s/-ignore *\"[[^\"]]*\"/ /g | |
s/-def *'[[^']]*'/ /g; s/-def *\"[[^\"]]*\"/ /g"` ;; | |
# If we are using Cray Fortran then delete quotes. | |
*cft90*) | |
ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed 's/"//g'` ;; | |
esac | |
])# _AC_PROG_FC_V_OUTPUT | |
# _AC_PROG_FC_V | |
# -------------- | |
# | |
# Determine the flag that causes the Fortran compiler to print | |
# information of library and object files (normally -v) | |
# Needed for _AC_FC_LIBRARY_FLAGS | |
# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###) | |
AC_DEFUN([_AC_PROG_FC_V], | |
[_AC_FORTRAN_ASSERT()dnl | |
AC_CACHE_CHECK([how to get verbose linking output from $[]_AC_FC[]], | |
[ac_cv_prog_[]_AC_LANG_ABBREV[]_v], | |
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], | |
[ac_cv_prog_[]_AC_LANG_ABBREV[]_v= | |
# Try some options frequently used verbose output | |
for ac_verb in -v -verbose --verbose -V -\#\#\#; do | |
_AC_PROG_FC_V_OUTPUT($ac_verb) | |
# look for -l* and *.a constructs in the output | |
for ac_arg in $ac_[]_AC_LANG_ABBREV[]_v_output; do | |
case $ac_arg in | |
[[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*) | |
ac_cv_prog_[]_AC_LANG_ABBREV[]_v=$ac_verb | |
break 2 ;; | |
esac | |
done | |
done | |
if test -z "$ac_cv_prog_[]_AC_LANG_ABBREV[]_v"; then | |
AC_MSG_WARN([cannot determine how to obtain linking information from $[]_AC_FC[]]) | |
fi], | |
[AC_MSG_WARN([compilation failed])]) | |
])])# _AC_PROG_FC_V | |
# _AC_FC_LIBRARY_LDFLAGS | |
# ---------------------- | |
# | |
# Determine the linker flags (e.g. "-L" and "-l") for the Fortran | |
# intrinsic and runtime libraries that are required to successfully | |
# link a Fortran program or shared library. The output variable | |
# FLIBS/FCLIBS 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, source code into a single | |
# program or shared library. | |
# | |
# For example, if object files from a C++ and Fortran 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 intrinsic and runtime libraries must be | |
# linked in as well, but the C++ compiler/linker doesn't know how to | |
# add these Fortran libraries. Hence, the macro | |
# "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran | |
# 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_FC_LIBRARY_LDFLAGS], | |
[_AC_FORTRAN_ASSERT()dnl | |
_AC_PROG_FC_V | |
AC_CACHE_CHECK([for _AC_LANG libraries of $[]_AC_FC[]], ac_cv_[]_AC_LANG_ABBREV[]_libs, | |
[if test "x$[]_AC_LANG_PREFIX[]LIBS" != "x"; then | |
ac_cv_[]_AC_LANG_ABBREV[]_libs="$[]_AC_LANG_PREFIX[]LIBS" # Let the user override the test. | |
else | |
_AC_PROG_FC_V_OUTPUT | |
ac_cv_[]_AC_LANG_ABBREV[]_libs= | |
# Save positional arguments (if any) | |
ac_save_positional="$[@]" | |
set X $ac_[]_AC_LANG_ABBREV[]_v_output | |
while test $[@%:@] != 1; do | |
shift | |
ac_arg=$[1] | |
case $ac_arg in | |
[[\\/]]*.a | ?:[[\\/]]*.a) | |
_AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , | |
ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg") | |
;; | |
-bI:*) | |
_AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , | |
[_AC_LINKER_OPTION([$ac_arg], ac_cv_[]_AC_LANG_ABBREV[]_libs)]) | |
;; | |
# Ignore these flags. | |
-lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -little \ | |
|-LANG:=* | -LIST:* | -LNO:*) | |
;; | |
-lkernel32) | |
test x"$CYGWIN" != xyes && ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg" | |
;; | |
-[[LRuYz]]) | |
# 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 `AS_ECHO(["$ac_arg"]) | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do | |
_AC_LIST_MEMBER_IF($ac_j, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , | |
[ac_arg="$ac_arg $ac_j" | |
ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_j"]) | |
done | |
;; | |
-[[lLR]]*) | |
_AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , | |
ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg") | |
;; | |
-zallextract*| -zdefaultextract) | |
ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $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=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_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_[]_AC_LANG_ABBREV[]_libs) | |
;; | |
esac | |
fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x" | |
]) | |
[]_AC_LANG_PREFIX[]LIBS="$ac_cv_[]_AC_LANG_ABBREV[]_libs" | |
AC_SUBST([]_AC_LANG_PREFIX[]LIBS) | |
])# _AC_FC_LIBRARY_LDFLAGS | |
# AC_F77_LIBRARY_LDFLAGS | |
# ---------------------- | |
AC_DEFUN([AC_F77_LIBRARY_LDFLAGS], | |
[AC_REQUIRE([AC_PROG_F77])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
_AC_FC_LIBRARY_LDFLAGS | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_F77_LIBRARY_LDFLAGS | |
# AC_FC_LIBRARY_LDFLAGS | |
# ---------------------- | |
AC_DEFUN([AC_FC_LIBRARY_LDFLAGS], | |
[AC_REQUIRE([AC_PROG_FC])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
_AC_FC_LIBRARY_LDFLAGS | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_LIBRARY_LDFLAGS | |
# _AC_FC_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,FC}_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,FC} 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,FC}_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_FC_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_FC_DUMMY_MAIN], | |
[_AC_FORTRAN_ASSERT()dnl | |
m4_define(_AC_LANG_PROGRAM_C_[]_AC_FC[]_HOOKS, | |
[#ifdef ]_AC_FC[_DUMMY_MAIN | |
]AC_LANG_CASE([Fortran], [#ifndef FC_DUMMY_MAIN_EQ_F77]) | |
[# ifdef __cplusplus | |
extern "C" | |
# endif | |
int ]_AC_FC[_DUMMY_MAIN() { return 1; } | |
]AC_LANG_CASE([Fortran], [#endif]) | |
[#endif | |
]) | |
AC_CACHE_CHECK([for dummy main to link with _AC_LANG libraries], | |
ac_cv_[]_AC_LANG_ABBREV[]_dummy_main, | |
[ac_[]_AC_LANG_ABBREV[]_dm_save_LIBS=$LIBS | |
LIBS="$LIBS $[]_AC_LANG_PREFIX[]LIBS" | |
ac_fortran_dm_var=[]_AC_FC[]_DUMMY_MAIN | |
AC_LANG_PUSH(C)dnl | |
# First, try linking without a dummy main: | |
AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], | |
[ac_cv_fortran_dummy_main=none], | |
[ac_cv_fortran_dummy_main=unknown]) | |
if test $ac_cv_fortran_dummy_main = unknown; then | |
for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do | |
AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@define $ac_fortran_dm_var $ac_func]])], | |
[ac_cv_fortran_dummy_main=$ac_func; break]) | |
done | |
fi | |
AC_LANG_POP(C)dnl | |
ac_cv_[]_AC_LANG_ABBREV[]_dummy_main=$ac_cv_fortran_dummy_main | |
rm -rf conftest* | |
LIBS=$ac_[]_AC_LANG_ABBREV[]_dm_save_LIBS | |
]) | |
[]_AC_FC[]_DUMMY_MAIN=$ac_cv_[]_AC_LANG_ABBREV[]_dummy_main | |
AS_IF([test "$[]_AC_FC[]_DUMMY_MAIN" != unknown], | |
[m4_default([$1], | |
[if test $[]_AC_FC[]_DUMMY_MAIN != none; then | |
AC_DEFINE_UNQUOTED([]_AC_FC[]_DUMMY_MAIN, $[]_AC_FC[]_DUMMY_MAIN, | |
[Define to dummy `main' function (if any) required to | |
link to the Fortran libraries.]) | |
if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then | |
AC_DEFINE([FC_DUMMY_MAIN_EQ_F77], 1, | |
[Define if F77 and FC dummy `main' functions are identical.]) | |
fi | |
fi])], | |
[m4_default([$2], | |
[AC_MSG_FAILURE([linking to Fortran libraries from C fails])])]) | |
])# _AC_FC_DUMMY_MAIN | |
# AC_F77_DUMMY_MAIN | |
# ---------------------- | |
AC_DEFUN([AC_F77_DUMMY_MAIN], | |
[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
_AC_FC_DUMMY_MAIN($@) | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_F77_DUMMY_MAIN | |
# AC_FC_DUMMY_MAIN | |
# ---------------------- | |
AC_DEFUN([AC_FC_DUMMY_MAIN], | |
[AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
_AC_FC_DUMMY_MAIN($@) | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_DUMMY_MAIN | |
# _AC_FC_MAIN | |
# ----------- | |
# Define {F77,FC}_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_FC_DUMMY_MAIN, above. | |
# If no such alternate name is found, just define {F77,FC}_MAIN to main. | |
# | |
AC_DEFUN([_AC_FC_MAIN], | |
[_AC_FORTRAN_ASSERT()dnl | |
AC_CACHE_CHECK([for alternate main to link with _AC_LANG libraries], | |
ac_cv_[]_AC_LANG_ABBREV[]_main, | |
[ac_[]_AC_LANG_ABBREV[]_m_save_LIBS=$LIBS | |
LIBS="$LIBS $[]_AC_LANG_PREFIX[]LIBS" | |
ac_fortran_dm_var=[]_AC_FC[]_DUMMY_MAIN | |
AC_LANG_PUSH(C)dnl | |
ac_cv_fortran_main="main" # default entry point name | |
for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do | |
AC_LINK_IFELSE([AC_LANG_PROGRAM([@%:@ifdef FC_DUMMY_MAIN_EQ_F77 | |
@%:@ undef F77_DUMMY_MAIN | |
@%:@ undef FC_DUMMY_MAIN | |
@%:@else | |
@%:@ undef $ac_fortran_dm_var | |
@%:@endif | |
@%:@define main $ac_func])], | |
[ac_cv_fortran_main=$ac_func; break]) | |
done | |
AC_LANG_POP(C)dnl | |
ac_cv_[]_AC_LANG_ABBREV[]_main=$ac_cv_fortran_main | |
rm -rf conftest* | |
LIBS=$ac_[]_AC_LANG_ABBREV[]_m_save_LIBS | |
]) | |
AC_DEFINE_UNQUOTED([]_AC_FC[]_MAIN, $ac_cv_[]_AC_LANG_ABBREV[]_main, | |
[Define to alternate name for `main' routine that is | |
called from a `main' in the Fortran libraries.]) | |
])# _AC_FC_MAIN | |
# AC_F77_MAIN | |
# ----------- | |
AC_DEFUN([AC_F77_MAIN], | |
[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
_AC_FC_MAIN | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_F77_MAIN | |
# AC_FC_MAIN | |
# ---------- | |
AC_DEFUN([AC_FC_MAIN], | |
[AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
_AC_FC_MAIN | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_MAIN | |
# __AC_FC_NAME_MANGLING | |
# --------------------- | |
# Test for the name mangling scheme used by the Fortran compiler. | |
# | |
# Sets ac_cv_{f77,fc}_mangling. The value contains three fields, separated | |
# by commas: | |
# | |
# lower case / upper case: | |
# case translation of the Fortran 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_FC_NAME_MANGLING], | |
[_AC_FORTRAN_ASSERT()dnl | |
AC_CACHE_CHECK([for _AC_LANG name-mangling scheme], | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling, | |
[AC_COMPILE_IFELSE( | |
[ subroutine foobar() | |
return | |
end | |
subroutine foo_bar() | |
return | |
end], | |
[mv conftest.$ac_objext cfortran_test.$ac_objext | |
ac_save_LIBS=$LIBS | |
LIBS="cfortran_test.$ac_objext $LIBS $[]_AC_LANG_PREFIX[]LIBS" | |
AC_LANG_PUSH(C)dnl | |
ac_success=no | |
for ac_foobar in foobar FOOBAR; do | |
for ac_underscore in "" "_"; do | |
ac_func="$ac_foobar$ac_underscore" | |
AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])], | |
[ac_success=yes; break 2]) | |
done | |
done | |
AC_LANG_POP(C)dnl | |
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_LANG_PUSH(C)dnl | |
ac_success_extra=no | |
for ac_extra in "" "_"; do | |
ac_func="$ac_foo_bar$ac_underscore$ac_extra" | |
AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])], | |
[ac_success_extra=yes; break]) | |
done | |
AC_LANG_POP(C)dnl | |
if test "$ac_success_extra" = "yes"; then | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_case case" | |
if test -z "$ac_underscore"; then | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, no underscore" | |
else | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, underscore" | |
fi | |
if test -z "$ac_extra"; then | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, no extra underscore" | |
else | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, extra underscore" | |
fi | |
else | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="unknown" | |
fi | |
else | |
ac_cv_[]_AC_LANG_ABBREV[]_mangling="unknown" | |
fi | |
LIBS=$ac_save_LIBS | |
rm -rf conftest* | |
rm -f cfortran_test*], | |
[AC_MSG_FAILURE([cannot compile a simple Fortran program])]) | |
]) | |
])# __AC_FC_NAME_MANGLING | |
# The replacement is empty. | |
AU_DEFUN([AC_F77_NAME_MANGLING], []) | |
# _AC_F77_NAME_MANGLING | |
# ---------------------- | |
AC_DEFUN([_AC_F77_NAME_MANGLING], | |
[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl | |
AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
__AC_FC_NAME_MANGLING | |
AC_LANG_POP(Fortran 77)dnl | |
])# _AC_F77_NAME_MANGLING | |
# _AC_FC_NAME_MANGLING | |
# ---------------------- | |
AC_DEFUN([_AC_FC_NAME_MANGLING], | |
[AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl | |
AC_REQUIRE([AC_FC_DUMMY_MAIN])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
__AC_FC_NAME_MANGLING | |
AC_LANG_POP(Fortran)dnl | |
])# _AC_FC_NAME_MANGLING | |
# _AC_FC_WRAPPERS | |
# --------------- | |
# Defines C macros {F77,FC}_FUNC(name,NAME) and {F77,FC}_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 compiler. | |
AC_DEFUN([_AC_FC_WRAPPERS], | |
[_AC_FORTRAN_ASSERT()dnl | |
AH_TEMPLATE(_AC_FC[_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(_AC_FC[_FUNC_], | |
[As ]_AC_FC[_FUNC, but for C identifiers containing underscores.])dnl | |
case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in | |
"lower case, no underscore, no extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name]) ;; | |
"lower case, no underscore, extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] _]) ;; | |
"lower case, underscore, no extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name [##] _]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] _]) ;; | |
"lower case, underscore, extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name [##] _]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] __]) ;; | |
"upper case, no underscore, no extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME]) ;; | |
"upper case, no underscore, extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] _]) ;; | |
"upper case, underscore, no extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME [##] _]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] _]) ;; | |
"upper case, underscore, extra underscore") | |
AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME [##] _]) | |
AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] __]) ;; | |
*) | |
AC_MSG_WARN([unknown Fortran name-mangling scheme]) | |
;; | |
esac | |
])# _AC_FC_WRAPPERS | |
# AC_F77_WRAPPERS | |
# --------------- | |
AC_DEFUN([AC_F77_WRAPPERS], | |
[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
_AC_FC_WRAPPERS | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_F77_WRAPPERS | |
# AC_FC_WRAPPERS | |
# -------------- | |
AC_DEFUN([AC_FC_WRAPPERS], | |
[AC_REQUIRE([_AC_FC_NAME_MANGLING])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
_AC_FC_WRAPPERS | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_WRAPPERS | |
# _AC_FC_FUNC(NAME, [SHELLVAR = NAME]) | |
# ------------------------------------ | |
# For a Fortran subroutine of given NAME, define a shell variable | |
# $SHELLVAR to the Fortran-mangled name. If the SHELLVAR | |
# argument is not supplied, it defaults to NAME. | |
AC_DEFUN([_AC_FC_FUNC], | |
[_AC_FORTRAN_ASSERT()dnl | |
case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in | |
upper*) ac_val="m4_toupper([$1])" ;; | |
lower*) ac_val="m4_tolower([$1])" ;; | |
*) ac_val="unknown" ;; | |
esac | |
case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac | |
m4_if(m4_index([$1],[_]),-1,[], | |
[case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac | |
]) | |
m4_default([$2],[$1])="$ac_val" | |
])# _AC_FC_FUNC | |
# AC_F77_FUNC(NAME, [SHELLVAR = NAME]) | |
# ------------------------------------ | |
AC_DEFUN([AC_F77_FUNC], | |
[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl | |
AC_LANG_PUSH(Fortran 77)dnl | |
_AC_FC_FUNC([$1],[$2]) | |
AC_LANG_POP(Fortran 77)dnl | |
])# AC_F77_FUNC | |
# AC_FC_FUNC(NAME, [SHELLVAR = NAME]) | |
# ----------------------------------- | |
AC_DEFUN([AC_FC_FUNC], | |
[AC_REQUIRE([_AC_FC_NAME_MANGLING])dnl | |
AC_LANG_PUSH(Fortran)dnl | |
_AC_FC_FUNC([$1],[$2]) | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_FUNC | |
# AC_FC_SRCEXT(EXT, [ACTION-IF-SUCCESS], [ACTION-IF-FAILURE]) | |
# ----------------------------------------------------------- | |
# Set the source-code extension used in Fortran (FC) tests to EXT (which | |
# defaults to f). Also, look for any necessary additional FCFLAGS needed | |
# to allow this extension, and store them in the output variable | |
# FCFLAGS_<EXT> (e.g. FCFLAGS_f90 for EXT=f90). If successful, | |
# call ACTION-IF-SUCCESS. If unable to compile source code with EXT, | |
# call ACTION-IF-FAILURE, which defaults to failing with an error | |
# message. | |
# | |
# (The flags for the current source-code extension, if any, are stored in | |
# $ac_fcflags_srcext and used automatically in subsequent autoconf tests.) | |
# | |
# For ordinary extensions like f90, etcetera, the modified FCFLAGS | |
# are currently needed for IBM's xlf* and Intel's ifc (grrr). Unfortunately, | |
# xlf* will only take flags to recognize one extension at a time, so if the | |
# user wants to compile multiple extensions (.f90 and .f95, say), she | |
# will need to use the FCFLAGS_F90 and FCFLAGS_F95 individually rather | |
# than just adding them all to FCFLAGS, for example. | |
# | |
# Also, for Intel's ifc compiler (which does not accept .f95 by default in | |
# some versions), the $FCFLAGS_<EXT> variable *must* go immediately before | |
# the source file on the command line, unlike other $FCFLAGS. Ugh. | |
AC_DEFUN([AC_FC_SRCEXT], | |
[AC_LANG_PUSH(Fortran)dnl | |
AC_CACHE_CHECK([for Fortran flag to compile .$1 files], | |
ac_cv_fc_srcext_$1, | |
[ac_ext=$1 | |
ac_fcflags_srcext_save=$ac_fcflags_srcext | |
ac_fcflags_srcext= | |
ac_cv_fc_srcext_$1=unknown | |
for ac_flag in none -qsuffix=f=$1 -Tf; do | |
test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag" | |
AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_fc_srcext_$1=$ac_flag; break]) | |
done | |
rm -f conftest.$ac_objext conftest.$1 | |
ac_fcflags_srcext=$ac_fcflags_srcext_save | |
]) | |
if test "x$ac_cv_fc_srcext_$1" = xunknown; then | |
m4_default([$3],[AC_MSG_ERROR([Fortran could not compile .$1 files])]) | |
else | |
ac_fc_srcext=$1 | |
if test "x$ac_cv_fc_srcext_$1" = xnone; then | |
ac_fcflags_srcext="" | |
FCFLAGS_[]$1[]="" | |
else | |
ac_fcflags_srcext=$ac_cv_fc_srcext_$1 | |
FCFLAGS_[]$1[]=$ac_cv_fc_srcext_$1 | |
fi | |
AC_SUBST(FCFLAGS_[]$1) | |
$2 | |
fi | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_SRCEXT | |
# AC_FC_FREEFORM([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) | |
# ------------------------------------------------------------------ | |
# Look for a compiler flag to make the Fortran (FC) compiler accept | |
# free-format source code, and adds it to FCFLAGS. Call | |
# ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can | |
# compile code using new extension) and ACTION-IF-FAILURE (defaults to | |
# failing with an error message) if not. (Defined via DEFUN_ONCE to | |
# prevent flag from being added to FCFLAGS multiple times.) | |
# | |
# The known flags are: | |
# -ffree-form: GNU g77 | |
# -FR: Intel compiler (icc, ecc) | |
# -free: Compaq compiler (fort) | |
# -qfree: IBM compiler (xlf) | |
# -Mfree, -Mfreeform: Portland Group compiler | |
# -freeform: SGI compiler | |
# -f free: Absoft Fortran | |
# We try to test the "more popular" flags first, by some prejudiced | |
# notion of popularity. | |
AC_DEFUN_ONCE([AC_FC_FREEFORM], | |
[AC_LANG_PUSH(Fortran)dnl | |
AC_CACHE_CHECK([for Fortran flag needed to allow free-form source], | |
ac_cv_fc_freeform, | |
[ac_cv_fc_freeform=unknown | |
ac_fc_freeform_FCFLAGS_save=$FCFLAGS | |
for ac_flag in none -ffree-form -FR -free -qfree -Mfree -Mfreeform \ | |
-freeform "-f free" | |
do | |
test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_freeform_FCFLAGS_save $ac_flag" | |
dnl Use @&t@ below to ensure that editors don't turn 8+ spaces into tab. | |
AC_COMPILE_IFELSE([ | |
program freeform | |
! FIXME: how to best confuse non-freeform compilers? | |
print *, 'Hello ', & | |
@&t@ 'world.' | |
end], | |
[ac_cv_fc_freeform=$ac_flag; break]) | |
done | |
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext | |
FCFLAGS=$ac_fc_freeform_FCFLAGS_save | |
]) | |
if test "x$ac_cv_fc_freeform" = xunknown; then | |
m4_default([$2], | |
[AC_MSG_ERROR([Fortran does not accept free-form source], 77)]) | |
else | |
if test "x$ac_cv_fc_freeform" != xnone; then | |
FCFLAGS="$FCFLAGS $ac_cv_fc_freeform" | |
fi | |
$1 | |
fi | |
AC_LANG_POP(Fortran)dnl | |
])# AC_FC_FREEFORM |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment