# This file is part of Autoconf.                       -*- Autoconf -*-# Fortran languages support.# Copyright (C) 2001, 2003# 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.# 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.# _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])])dnlm4_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"  doneelse  $2="[$]$2 $1"fi[]dnl])# _AC_LINKER_OPTION## ----------------------- #### 1. Language selection.  #### ----------------------- ### -------------------------- ## 1d. The Fortran language.  ## -------------------------- ## AC_LANG(Fortran 77)# -------------------m4_define([AC_LANG(Fortran 77)],[ac_ext=fac_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(Fortran)# ----------------m4_define([AC_LANG(Fortran)],[ac_ext=${FC_SRCEXT-f}ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&AS_MESSAGE_LOG_FD'ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'ac_compiler_gnu=$ac_cv_fc_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_LANG_ABBREV(Fortran 77)# ---------------------------m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77])# _AC_LANG_ABBREV(Fortran)# ------------------------m4_define([_AC_LANG_ABBREV(Fortran)], [fc])# _AC_LANG_PREFIX(Fortran 77)# ---------------------------m4_define([_AC_LANG_PREFIX(Fortran 77)], [F])# _AC_LANG_PREFIX(Fortran)# ------------------------m4_define([_AC_LANG_PREFIX(Fortran)], [FC])# _AC_FC# ------# Return F77 or FC, depending upon the language.AC_DEFUN([_AC_FC],[_AC_FORTRAN_ASSERT()dnlAC_LANG_CASE([Fortran 77], [F77],             [Fortran],    [FC])])## ---------------------- #### 2.Producing programs.  #### ---------------------- ### --------------------- ## 2d. Fortran sources.  ## --------------------- ## AC_LANG_SOURCE(Fortran 77)(BODY)# AC_LANG_SOURCE(Fortran)(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])m4_define([AC_LANG_SOURCE(Fortran)],[$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_PROGRAM(Fortran)([PROLOGUE], [BODY])# -----------------------------------------------# FIXME: can the PROLOGUE be used?m4_define([AC_LANG_PROGRAM(Fortran)],[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])])# AC_LANG_CALL(Fortran)(PROLOGUE, FUNCTION)# --------------------------------------------# FIXME: This is a guess, help!m4_define([AC_LANG_CALL(Fortran)],[AC_LANG_PROGRAM([$1],[      call $2])])## -------------------------------------------- #### 3. Looking for Compilers and Preprocessors.  #### -------------------------------------------- ### -------------------------- ## 3d. The Fortran 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_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: putative GNU Fortran 95+ compiler (in progress)#  fort77: native F77 compiler under HP-UX (and some older Crays)#  frt: Fujitsu F77 compiler#  pgf77/pgf90/pgf95: Portland Group F77/F90/F95 compilers#  xlf/xlf90/xlf95: IBM (AIX) F77/F90/F95 compilers#  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#  ifc: Intel Fortran 95 compiler for Linux/x86#  efc: Intel Fortran 95 compiler for IA64m4_define([_AC_F95_FC], [f95 fort xlf95 ifc efc pgf95 lf95 gfortran])m4_define([_AC_F90_FC], [f90 xlf90 pgf90 epcf90])m4_define([_AC_F77_FC], [g77 f77 xlf frt pgf77 fort77 fl32 af77])AC_DEFUN([_AC_PROG_FC],[_AC_FORTRAN_ASSERT()dnlAC_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.echo "$as_me:__oline__:" \     "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FDac_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])rm -f a.outm4_expand_once([_AC_COMPILER_EXEEXT])[]dnlm4_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_extac_ext=F_AC_LANG_COMPILER_GNUac_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)dnlAC_ARG_VAR([F77],    [Fortran 77 compiler command])dnlAC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl_AC_ARG_VAR_LDFLAGS()dnl_AC_PROG_FC([Fortran 77], [$1])G77=`test $ac_compiler_gnu = yes && echo yes`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)dnlAC_ARG_VAR([FC],    [Fortran compiler command])dnlAC_ARG_VAR([FCFLAGS], [Fortran compiler flags])dnl