diff --git a/m4/fortran.m4 b/m4/fortran.m4 new file mode 100644 index 0000000000000000000000000000000000000000..11822fbd683251a6eb57595297bb98c6482cd67d --- /dev/null +++ b/m4/fortran.m4 @@ -0,0 +1,811 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Fortran languages support. +# Copyright 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. + + +# _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], , [AC_FATAL([$0: missing argument 1])])dnl +m4_if([$2], , [AC_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 + + + +## ----------------------- ## +## 1. Language selection. ## +## ----------------------- ## + + +# ----------------------------- # +# 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. ## +## ---------------------- ## + + +# ------------------------ # +# 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. ## +## -------------------------------------------- ## + + +# ----------------------------- # +# 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' is a wrapper around `f2c'. +# It is believed that under HP-UX `fort77' is the name of the native +# compiler. On some Cray systems, fort77 is a native compiler. +# 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 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 -f conftest*]) +if test $ac_cv_prog_f77_c_o = no; then + AC_DEFINE(F77_NO_MINUS_C_MINUS_O, 1, + [Define to 1 if your Fortran 77 compiler doesn't accept + -c and -o together.]) +fi +])# AC_PROG_F77_C_O + + + + + +## ------------------------------- ## +## 4. Compilers' characteristics. ## +## ------------------------------- ## + + +# ---------------------------------------- # +# 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 -f 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 + +# 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_f77_v_output="`echo $ac_f77_v_output | + grep 'LPATH is:' | + sed 's,.*LPATH is\(: *[[^ ]]*\).*,\1,;s,: */, -L/,g'` $ac_f77_v_output" + +# 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_IF($ac_arg, $ac_cv_flibs, , + ac_cv_flibs="$ac_cv_flibs $ac_arg") + ;; + -bI:*) + _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_flibs, , + [_AC_LINKER_OPTION([$ac_arg], ac_cv_flibs)]) + ;; + # Ignore these flags. +# -lang* | -lcrt[[0-9]].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*) + -lang* | -lcrt[[0-9]].o | -lc | -lgcc | -libmil | -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_IF($ac_j, $ac_cv_flibs, , + [ac_arg="$ac_arg $ac_j" + ac_cv_flibs="$ac_cv_flibs $ac_j"]) + done + ;; + -[[lLR]]*) + _AC_LIST_MEMBER_IF($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_LINK_IFELSE([AC_LANG_PROGRAM([], [])], + [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_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@define F77_DUMMY_MAIN $ac_func]])], + [ac_cv_f77_dummy_main=$ac_func; break]) + done + fi + rm -f 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_FAILURE([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_LINK_IFELSE([AC_LANG_PROGRAM([@%:@undef F77_DUMMY_MAIN +@%:@define main $ac_func])], + [ac_cv_f77_main=$ac_func; break]) + done + rm -f 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_LINK_IFELSE([AC_LANG_CALL([], [$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_LINK_IFELSE([AC_LANG_CALL([], [$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 -f cf77_test* conftest*], + [AC_MSG_FAILURE([cannot compile a simple Fortran program])]) +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