| # This file is part of Autoconf. -*- Autoconf -*- |
| # Fortran languages support. |
| # Copyright (C) 2001, 2003-2012 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/pgfortran: 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 files |
| # 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 |
| # nagfor: NAGWare Fortran 77/90/95 compiler |
| m4_define([_AC_F95_FC], [gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor]) |
| 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]) |
| if test $ac_compiler_gnu = yes; then |
| GFC=yes |
| else |
| GFC= |
| fi |
| 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 | |
| sed '/^Driving:/d; /^Configured with:/d; |
| '"/^[[_$as_cr_Letters]][[_$as_cr_alnum]]*=/d"` |
| 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 |
| # With xlf replace commas with spaces, |
| # and remove "-link" and closing parenthesis. |
| *xlfentry*) |
| ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | |
| sed ' |
| s/,/ /g |
| s/ -link / /g |
| s/) *$// |
| ' |
| ` ;; |
| |
| # 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 fort77 (the f2c wrapper) then filter output and delete quotes. |
| *fort77*f2c*gcc*) |
| ac_[]_AC_LANG_ABBREV[]_v_output=`echo "$ac_[]_AC_LANG_ABBREV[]_v_output" | sed -n ' |
| /:[[ ]]\+Running[[ ]]\{1,\}"gcc"/{ |
| /"-c"/d |
| /[[.]]c"*/d |
| s/^.*"gcc"/"gcc"/ |
| s/"//gp |
| }'` ;; |
| |
| # 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_REQUIRE([AC_CANONICAL_HOST])dnl |
| _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:* | -link) |
| ;; |
| -lkernel32) |
| case $host_os in |
| *cygwin*) ;; |
| *) ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg" |
| ;; |
| esac |
| ;; |
| -[[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. |
| # |
| # gfortran requires '-x f77' in order to recognize .f77 files. |
| 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 |
| case $ac_ext in #( |
| [[fF]]77) ac_try=f77;; #( |
| *) ac_try=f95;; |
| esac |
| for ac_flag in none -qsuffix=f=$1 -Tf "-x $ac_try"; 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_PP_SRCEXT(EXT, [ACTION-IF-SUCCESS], [ACTION-IF-FAILURE]) |
| # -------------------------------------------------------------- |
| # Like AC_FC_SRCEXT, 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 for preprocessed Fortran, 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 preprocessed |
| # source code with EXT, call ACTION-IF-FAILURE, which defaults to failing with |
| # an error message. |
| # |
| # Some compilers allow preprocessing with either a Fortran preprocessor or |
| # with the C preprocessor (cpp). Prefer the Fortran preprocessor, to deal |
| # correctly with continuation lines, `//' (not a comment), and preserve white |
| # space (for fixed form). |
| # |
| # (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 needed for IBM's xlf*. Also, for Intel's ifort compiler, the |
| # $FCFLAGS_<EXT> variable *must* go immediately before the source file on the |
| # command line, unlike other $FCFLAGS. Ugh. |
| # |
| # Known extensions that enable preprocessing by default, and flags to force it: |
| # GNU: .F .F90 .F95 .F03 .F08, -cpp for most others, |
| # -x f77-cpp-input for .f77 .F77; -x f95-cpp-input for gfortran < 4.4 |
| # SGI: .F .F90, -ftpp or -cpp for .f .f90, -E write preproc to stdout |
| # -macro_expand enable macro expansion everywhere (with -ftpp) |
| # -P preproc only, save in .i, no #line's |
| # SUN: .F .F95, -fpp for others; -xpp={fpp,cpp} for preprocessor selection |
| # -F preprocess only (save in lowercase extension) |
| # IBM: .F .F77 .F90 .F95 .F03, -qsuffix=cpp=EXT for extension .EXT to invoke cpp |
| # -WF,-qnofpp -WF,-qfpp=comment:linecont:nocomment:nolinecont |
| # -WF,-qlanglvl=classic or not -qnoescape (trigraph problems) |
| # -d no #line in output, -qnoobject for preprocessing only (output in .f) |
| # -q{no,}ppsuborigarg substitute original macro args before expansion |
| # HP: .F, +cpp={yes|no|default} use cpp, -cpp, +cpp_keep save in .i/.i90 |
| # PGI: -Mpreprocess |
| # Absoft: .F .FOR .F90 .F95, -cpp for others |
| # Cray: .F .F90 .FTN, -e Z for others; -F enable macro expansion everywhere |
| # Intel: .F .F90, -fpp for others, but except for .f and .f90, -Tf may also be |
| # needed right before the source file name |
| # PathScale: .F .F90 .F95, -ftpp or -cpp for .f .f90 .f95 |
| # -macro_expand for expansion everywhere, -P for no #line in output |
| # Lahey: .F .FOR .F90 .F95, -Cpp |
| # NAGWare: .F .F90 .F95, .ff .ff90 .ff95 (new), -fpp for others |
| # Compaq/Tru64: .F .F90, -cpp, -P keep .i file, -P keep .i file |
| # f2c: .F, -cpp |
| # g95: .F .FOR .F90 .F95 .F03, -cpp -no-cpp, -E for stdout |
| AC_DEFUN([AC_FC_PP_SRCEXT], |
| [AC_LANG_PUSH(Fortran)dnl |
| AC_CACHE_CHECK([for Fortran flag to compile preprocessed .$1 files], |
| ac_cv_fc_pp_srcext_$1, |
| [ac_ext=$1 |
| ac_fcflags_pp_srcext_save=$ac_fcflags_srcext |
| ac_fcflags_srcext= |
| ac_cv_fc_pp_srcext_$1=unknown |
| case $ac_ext in #( |
| [[fF]]77) ac_try=f77-cpp-input;; #( |
| *) ac_try=f95-cpp-input;; |
| esac |
| for ac_flag in none -ftpp -fpp -Tf "-fpp -Tf" -xpp=fpp -Mpreprocess "-e Z" \ |
| -cpp -xpp=cpp -qsuffix=cpp=$1 "-x $ac_try" +cpp -Cpp; do |
| test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag" |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ |
| #if 0 |
| #include <ac_nonexistent.h> |
| choke me |
| #endif]])], |
| [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ |
| #if 1 |
| #include <ac_nonexistent.h> |
| choke me |
| #endif]])], |
| [], |
| [ac_cv_fc_pp_srcext_$1=$ac_flag; break])]) |
| done |
| rm -f conftest.$ac_objext conftest.$1 |
| ac_fcflags_srcext=$ac_fcflags_pp_srcext_save |
| ]) |
| if test "x$ac_cv_fc_pp_srcext_$1" = xunknown; then |
| m4_default([$3], |
| [AC_MSG_ERROR([Fortran could not compile preprocessed .$1 files])]) |
| else |
| ac_fc_srcext=$1 |
| if test "x$ac_cv_fc_pp_srcext_$1" = xnone; then |
| ac_fcflags_srcext="" |
| FCFLAGS_[]$1[]="" |
| else |
| ac_fcflags_srcext=$ac_cv_fc_pp_srcext_$1 |
| FCFLAGS_[]$1[]=$ac_cv_fc_pp_srcext_$1 |
| fi |
| AC_SUBST(FCFLAGS_[]$1) |
| $2 |
| fi |
| AC_LANG_POP(Fortran)dnl |
| ])# AC_FC_PP_SRCEXT |
| |
| |
| # AC_FC_PP_DEFINE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ------------------------------------------------------------------- |
| # Find a flag to specify defines for preprocessed Fortran. Not all |
| # Fortran compilers use -D. Substitute FC_DEFINE with the result and |
| # call ACTION-IF-SUCCESS (defaults to nothing) if successful, and |
| # ACTION-IF-FAILURE (defaults to failing with an error message) if not. |
| # |
| # Known flags: |
| # IBM: -WF,-D |
| # Lahey/Fujitsu: -Wp,-D older versions??? |
| # f2c: -D or -Wc,-D |
| # others: -D |
| AC_DEFUN([AC_FC_PP_DEFINE], |
| [AC_LANG_PUSH([Fortran])dnl |
| ac_fc_pp_define_srcext_save=$ac_fc_srcext |
| AC_FC_PP_SRCEXT([F]) |
| AC_CACHE_CHECK([how to define symbols for preprocessed Fortran], |
| [ac_cv_fc_pp_define], |
| [ac_fc_pp_define_srcext_save=$ac_fc_srcext |
| ac_cv_fc_pp_define=unknown |
| ac_fc_pp_define_FCFLAGS_save=$FCFLAGS |
| for ac_flag in -D -WF,-D -Wp,-D -Wc,-D |
| do |
| FCFLAGS="$ac_fc_pp_define_FCFLAGS_save ${ac_flag}FOOBAR ${ac_flag}ZORK=42" |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ |
| #ifndef FOOBAR |
| choke me |
| #endif |
| #if ZORK != 42 |
| choke me |
| #endif]])], |
| [ac_cv_fc_pp_define=$ac_flag]) |
| test x"$ac_cv_fc_pp_define" != xunknown && break |
| done |
| FCFLAGS=$ac_fc_pp_define_FCFLAGS_save |
| ]) |
| ac_fc_srcext=$ac_fc_pp_define_srcext_save |
| if test "x$ac_cv_fc_pp_define" = xunknown; then |
| FC_DEFINE= |
| m4_default([$2], |
| [AC_MSG_ERROR([Fortran does not allow to define preprocessor symbols], 77)]) |
| else |
| FC_DEFINE=$ac_cv_fc_pp_define |
| $1 |
| fi |
| AC_SUBST([FC_DEFINE])dnl |
| AC_LANG_POP([Fortran])dnl |
| ]) |
| |
| |
| # 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, gfortran, g95 |
| # -FR, -free: Intel compiler (icc, ecc, ifort) |
| # -free: Compaq compiler (fort), Sun compiler (f95) |
| # -qfree: IBM compiler (xlf) |
| # -Mfree, -Mfreeform: Portland Group compiler |
| # -freeform: SGI compiler |
| # -8, -f free: Absoft Fortran |
| # +source=free: HP Fortran |
| # (-)-nfix, -Free: Lahey/Fujitsu Fortran |
| # -free: NAGWare |
| # -f, -Wf,-f: f2c (but only a weak form of "free-form" and long lines) |
| # 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 accept 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" -8 +source=free -nfix --nfix -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 |
| |
| |
| # AC_FC_FIXEDFORM([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ------------------------------------------------------------------ |
| # Look for a compiler flag to make the Fortran (FC) compiler accept |
| # fixed-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: |
| # -ffixed-form: GNU g77, gfortran, g95 |
| # -fixed: Intel compiler (ifort), Sun compiler (f95) |
| # -qfixed: IBM compiler (xlf*) |
| # -Mfixed: Portland Group compiler |
| # -fixedform: SGI compiler |
| # -f fixed: Absoft Fortran |
| # +source=fixed: HP Fortran |
| # (-)-fix, -Fixed: Lahey/Fujitsu Fortran |
| # -fixed: NAGWare |
| # Since compilers may accept fixed form based on file name extension, |
| # but users may want to use it with others as well, call AC_FC_SRCEXT |
| # with the respective source extension before calling this macro. |
| AC_DEFUN_ONCE([AC_FC_FIXEDFORM], |
| [AC_LANG_PUSH([Fortran])dnl |
| AC_CACHE_CHECK([for Fortran flag needed to accept fixed-form source], |
| [ac_cv_fc_fixedform], |
| [ac_cv_fc_fixedform=unknown |
| ac_fc_fixedform_FCFLAGS_save=$FCFLAGS |
| for ac_flag in none -ffixed-form -fixed -qfixed -Mfixed -fixedform "-f fixed" \ |
| +source=fixed -fix --fix -Fixed |
| do |
| test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_fixedform_FCFLAGS_save $ac_flag" |
| AC_COMPILE_IFELSE([[ |
| C This comment should confuse free-form compilers. |
| program main |
| end]], |
| [ac_cv_fc_fixedform=$ac_flag; break]) |
| done |
| rm -f conftest.err conftest.$ac_objext conftest.$ac_ext |
| FCFLAGS=$ac_fc_fixedform_FCFLAGS_save |
| ]) |
| if test "x$ac_cv_fc_fixedform" = xunknown; then |
| m4_default([$2], |
| [AC_MSG_ERROR([Fortran does not accept fixed-form source], 77)]) |
| else |
| if test "x$ac_cv_fc_fixedform" != xnone; then |
| FCFLAGS="$FCFLAGS $ac_cv_fc_fixedform" |
| fi |
| $1 |
| fi |
| AC_LANG_POP([Fortran])dnl |
| ])# AC_FC_FIXEDFORM |
| |
| |
| # AC_FC_LINE_LENGTH([LENGTH], [ACTION-IF-SUCCESS], |
| # [ACTION-IF-FAILURE = FAILURE]) |
| # ------------------------------------------------ |
| # Look for a compiler flag to make the Fortran (FC) compiler accept long lines |
| # in the current (free- or fixed-format) source code, and adds it to FCFLAGS. |
| # The optional LENGTH may be 80, 132 (default), or `unlimited' for longer |
| # lines. Note that line lengths above 254 columns are not portable, and some |
| # compilers (hello ifort) do not accept more than 132 columns at least for |
| # fixed format. 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.) |
| # You should call AC_FC_FREEFORM or AC_FC_FIXEDFORM to set the desired format |
| # prior to using this macro. |
| # |
| # The known flags are: |
| # -f{free,fixed}-line-length-N with N 72, 80, 132, or 0 or none for none. |
| # -ffree-line-length-none: GNU gfortran |
| # -ffree-line-length-huge: g95 (also -ffixed-line-length-N as above) |
| # -qfixed=132 80 72: IBM compiler (xlf) |
| # -Mextend: Cray |
| # -132 -80 -72: Intel compiler (ifort) |
| # Needs to come before -extend_source because ifort |
| # accepts that as well with an optional parameter and |
| # doesn't fail but only warns about unknown arguments. |
| # -extend_source: SGI compiler |
| # -W, -WNN (132, 80, 72): Absoft Fortran |
| # +es, +extend_source: HP Fortran (254 in either form, default is 72 fixed, |
| # 132 free) |
| # -w, (-)-wide: Lahey/Fujitsu Fortran (255 cols in fixed form) |
| # -e: Sun Fortran compiler (132 characters) |
| # -132: NAGWare |
| # -72, -f, -Wf,-f: f2c (a weak form of "free-form" and long lines). |
| # /XLine: Open Watcom |
| AC_DEFUN_ONCE([AC_FC_LINE_LENGTH], |
| [AC_LANG_PUSH([Fortran])dnl |
| m4_case(m4_default([$1], [132]), |
| [unlimited], [ac_fc_line_len_string=unlimited |
| ac_fc_line_len=0 |
| ac_fc_line_length_test=' |
| subroutine longer_than_132(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,'\ |
| 'arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19)'], |
| [132], [ac_fc_line_len=132 |
| ac_fc_line_length_test=' |
| subroutine longer_than_80(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,'\ |
| 'arg10)'], |
| [80], [ac_fc_line_len=80 |
| ac_fc_line_length_test=' |
| subroutine longer_than_72(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)'], |
| [m4_warning([Invalid length argument `$1'])]) |
| : ${ac_fc_line_len_string=$ac_fc_line_len} |
| AC_CACHE_CHECK( |
| [for Fortran flag needed to accept $ac_fc_line_len_string column source lines], |
| [ac_cv_fc_line_length], |
| [ac_cv_fc_line_length=unknown |
| ac_fc_line_length_FCFLAGS_save=$FCFLAGS |
| for ac_flag in none \ |
| -ffree-line-length-none -ffixed-line-length-none \ |
| -ffree-line-length-huge \ |
| -ffree-line-length-$ac_fc_line_len \ |
| -ffixed-line-length-$ac_fc_line_len \ |
| -qfixed=$ac_fc_line_len -Mextend \ |
| -$ac_fc_line_len -extend_source \ |
| -W$ac_fc_line_len -W +extend_source +es -wide --wide -w -e \ |
| -f -Wf,-f -xline |
| do |
| test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_line_length_FCFLAGS_save $ac_flag" |
| AC_COMPILE_IFELSE([[$ac_fc_line_length_test |
| end subroutine]], |
| [ac_cv_fc_line_length=$ac_flag; break]) |
| done |
| rm -f conftest.err conftest.$ac_objext conftest.$ac_ext |
| FCFLAGS=$ac_fc_line_length_FCFLAGS_save |
| ]) |
| if test "x$ac_cv_fc_line_length" = xunknown; then |
| m4_default([$3], |
| [AC_MSG_ERROR([Fortran does not accept long source lines], 77)]) |
| else |
| if test "x$ac_cv_fc_line_length" != xnone; then |
| FCFLAGS="$FCFLAGS $ac_cv_fc_line_length" |
| fi |
| $2 |
| fi |
| AC_LANG_POP([Fortran])dnl |
| ])# AC_FC_LINE_LENGTH |
| |
| |
| # AC_FC_CHECK_BOUNDS([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ---------------------------------------------------------------------- |
| # Look for a compiler flag to turn on array bounds checking for the |
| # Fortran (FC) compiler, 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: |
| # -fcheck=all, -fbounds-check: gfortran |
| # -fbounds-check: g77, g95 |
| # -CB, -check bounds: Intel compiler (icc, ecc, ifort) |
| # -C: Sun/Oracle compiler (f95) |
| # -C, -qcheck: IBM compiler (xlf) |
| # -Mbounds: Portland Group compiler |
| # -C ,-Mbounds: Cray |
| # -C, -check_bounds: SGI compiler |
| # -check_bounds, +check=all: HP Fortran |
| # -C, -Rb -Rc: Absoft (-Rb: array boundaries, -Rc: array conformance) |
| # --chk e,s -chk (e,s): Lahey |
| # -C -C=all: NAGWare |
| # -C, -ffortran-bounds-check: PathScale pathf90 |
| # -C: f2c |
| # -BOunds: Open Watcom |
| AC_DEFUN_ONCE([AC_FC_CHECK_BOUNDS], |
| [AC_LANG_PUSH([Fortran])dnl |
| AC_CACHE_CHECK([for Fortran flag to enable array-bounds checking], |
| [ac_cv_fc_check_bounds], |
| [ac_cv_fc_check_bounds=unknown |
| ac_fc_check_bounds_FCFLAGS_save=$FCFLAGS |
| for ac_flag in -fcheck=bounds -fbounds-check -check_bounds -Mbounds -qcheck \ |
| '-check bounds' +check=all --check '-Rb -Rc' -CB -C=all -C \ |
| -ffortran-bounds-check "--chk e,s" "-chk e -chk s" -bounds |
| do |
| FCFLAGS="$ac_fc_check_bounds_FCFLAGS_save $ac_flag" |
| # We should be able to link a correct program. |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], |
| [AC_LINK_IFELSE([[ |
| subroutine sub(a) |
| integer a(:) |
| a(8) = 0 |
| end subroutine |
| |
| program main |
| integer a(1:7) |
| interface |
| subroutine sub(a) |
| integer a(:) |
| end subroutine |
| end interface |
| |
| call sub(a) |
| end program]], |
| [# If we can run the program, require failure at run time. |
| # In cross-compiling mode, we rely on the compiler not accepting |
| # unknown options. |
| AS_IF([test "$cross_compiling" = yes], |
| [ac_cv_fc_check_bounds=$ac_flag; break], |
| [AS_IF([_AC_DO_TOKENS(./conftest$ac_exeext)], |
| [], |
| [ac_cv_fc_check_bounds=$ac_flag; break])])])]) |
| done |
| rm -f conftest$ac_exeext conftest.err conftest.$ac_objext conftest.$ac_ext \ |
| core *.core core.conftest.* |
| FCFLAGS=$ac_fc_check_bounds_FCFLAGS_save |
| ]) |
| if test "x$ac_cv_fc_check_bounds" = xunknown; then |
| m4_default([$2], |
| [AC_MSG_ERROR([no Fortran flag for bounds checking found], 77)]) |
| else |
| if test "x$ac_cv_fc_check_bounds" != xnone; then |
| FCFLAGS="$FCFLAGS $ac_cv_fc_check_bounds" |
| fi |
| $1 |
| fi |
| AC_LANG_POP([Fortran])dnl |
| ])# AC_FC_CHECK_BOUNDS |
| |
| |
| # _AC_FC_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ------------------------------------------------------------------------ |
| # Look for a flag to disallow implicit declarations, and add it to FCFLAGS. |
| # Call ACTION-IF-SUCCESS (defaults to nothing) if successful and |
| # ACTION-IF-FAILURE (defaults to failing with an error message) if not. |
| # |
| # Known flags: |
| # GNU gfortran, g95: -fimplicit-none, g77: -Wimplicit |
| # Intel: -u, -implicitnone; might also need '-warn errors' to turn into error. |
| # Sun/Oracle: -u |
| # HP: +implicit_none |
| # IBM: -u, -qundef |
| # SGI: -u |
| # Compaq: -u, -warn declarations |
| # NAGWare: -u |
| # Lahey: -in, --in, -AT |
| # Cray: -Mdclchk -e I |
| # PGI: -Mcdlchk |
| # f2c: -u |
| AC_DEFUN([_AC_FC_IMPLICIT_NONE], |
| [_AC_FORTRAN_ASSERT()dnl |
| AC_CACHE_CHECK([for flag to disallow _AC_LANG implicit declarations], |
| [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none], |
| [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none=unknown |
| ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save=$[]_AC_LANG_PREFIX[]FLAGS |
| for ac_flag in none -fimplicit-none -u -Wimplicit -implicitnone +implicit_none \ |
| -qundef "-warn declarations" -in --in -AT "-e I" -Mdclchk \ |
| "-u -warn errors" |
| do |
| if test "x$ac_flag" != xnone; then |
| _AC_LANG_PREFIX[]FLAGS="$ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save $ac_flag" |
| fi |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], |
| [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ |
| i = 0 |
| print *, i]])], |
| [], |
| [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none=$ac_flag; break])]) |
| done |
| rm -f conftest.err conftest.$ac_objext conftest.$ac_ext |
| _AC_LANG_PREFIX[]FLAGS=$ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save |
| ]) |
| if test "x$ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" = xunknown; then |
| m4_default([$3], |
| [AC_MSG_ERROR([no Fortran flag to disallow implicit declarations found], 77)]) |
| else |
| if test "x$ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" != xnone; then |
| _AC_LANG_PREFIX[]FLAGS="$_AC_LANG_PREFIX[]FLAGS $ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" |
| fi |
| $2 |
| fi |
| ])# _AC_FC_IMPLICIT_NONE |
| |
| |
| # AC_F77_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ------------------------------------------------------------------------ |
| AC_DEFUN([AC_F77_IMPLICIT_NONE], |
| [AC_LANG_PUSH([Fortran 77])dnl |
| _AC_FC_IMPLICIT_NONE($@) |
| AC_LANG_POP([Fortran 77])dnl |
| ])# AC_F77_IMPLICIT_NONE |
| |
| |
| # AC_FC_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ----------------------------------------------------------------------- |
| AC_DEFUN([AC_FC_IMPLICIT_NONE], |
| [AC_LANG_PUSH([Fortran])dnl |
| _AC_FC_IMPLICIT_NONE($@) |
| AC_LANG_POP([Fortran])dnl |
| ])# AC_FC_IMPLICIT_NONE |
| |
| |
| # AC_FC_MODULE_EXTENSION |
| # ---------------------- |
| # Find the Fortran 90 module file extension. The module extension is stored |
| # in the variable FC_MODEXT and empty if it cannot be determined. The result |
| # or "unknown" is cached in the cache variable ac_cv_fc_module_ext. |
| AC_DEFUN([AC_FC_MODULE_EXTENSION], |
| [AC_CACHE_CHECK([Fortran 90 module extension], [ac_cv_fc_module_ext], |
| [AC_LANG_PUSH(Fortran) |
| mkdir conftest.dir |
| cd conftest.dir |
| ac_cv_fc_module_ext=unknown |
| AC_COMPILE_IFELSE([[ |
| module conftest_module |
| contains |
| subroutine conftest_routine |
| write(*,'(a)') 'gotcha!' |
| end subroutine |
| end module]], |
| [ac_cv_fc_module_ext=`ls | sed -n 's,conftest_module\.,,p'` |
| if test x$ac_cv_fc_module_ext = x; then |
| dnl Some F90 compilers use upper case characters for the module file name. |
| ac_cv_fc_module_ext=`ls | sed -n 's,CONFTEST_MODULE\.,,p'` |
| fi]) |
| cd .. |
| rm -rf conftest.dir |
| AC_LANG_POP(Fortran) |
| ]) |
| FC_MODEXT=$ac_cv_fc_module_ext |
| if test "$FC_MODEXT" = unknown; then |
| FC_MODEXT= |
| fi |
| AC_SUBST([FC_MODEXT])dnl |
| ]) |
| |
| |
| # AC_FC_MODULE_FLAG([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # --------------------------------------------------------------------- |
| # Find a flag to include Fortran 90 modules from another directory. |
| # If successful, run ACTION-IF-SUCCESS (defaults to nothing), otherwise |
| # run ACTION-IF-FAILURE (defaults to failing with an error message). |
| # The module flag is cached in the ac_cv_fc_module_flag variable. |
| # It may contain significant trailing whitespace. |
| # |
| # Known flags: |
| # gfortran: -Idir, -I dir (-M dir, -Mdir (deprecated), -Jdir for writing) |
| # g95: -I dir (-fmod=dir for writing) |
| # SUN: -Mdir, -M dir (-moddir=dir for writing; |
| # -Idir for includes is also searched) |
| # HP: -Idir, -I dir (+moddir=dir for writing) |
| # IBM: -Idir (-qmoddir=dir for writing) |
| # Intel: -Idir -I dir (-mod dir for writing) |
| # Absoft: -pdir |
| # Lahey: -mod dir |
| # Cray: -module dir, -p dir (-J dir for writing) |
| # -e m is needed to enable writing .mod files at all |
| # Compaq: -Idir |
| # NAGWare: -I dir |
| # PathScale: -I dir (but -module dir is looked at first) |
| # Portland: -module dir (first -module also names dir for writing) |
| # Fujitsu: -Am -Idir (-Mdir for writing is searched first, then '.', then -I) |
| # (-Am indicates how module information is saved) |
| AC_DEFUN([AC_FC_MODULE_FLAG],[ |
| AC_CACHE_CHECK([Fortran 90 module inclusion flag], [ac_cv_fc_module_flag], |
| [AC_LANG_PUSH([Fortran]) |
| ac_cv_fc_module_flag=unknown |
| mkdir conftest.dir |
| cd conftest.dir |
| AC_COMPILE_IFELSE([[ |
| module conftest_module |
| contains |
| subroutine conftest_routine |
| write(*,'(a)') 'gotcha!' |
| end subroutine |
| end module]], |
| [cd .. |
| ac_fc_module_flag_FCFLAGS_save=$FCFLAGS |
| # Flag ordering is significant for gfortran and Sun. |
| for ac_flag in -M -I '-I ' '-M ' -p '-mod ' '-module ' '-Am -I'; do |
| # Add the flag twice to prevent matching an output flag. |
| FCFLAGS="$ac_fc_module_flag_FCFLAGS_save ${ac_flag}conftest.dir ${ac_flag}conftest.dir" |
| AC_COMPILE_IFELSE([[ |
| program main |
| use conftest_module |
| call conftest_routine |
| end program]], |
| [ac_cv_fc_module_flag="$ac_flag"]) |
| if test "$ac_cv_fc_module_flag" != unknown; then |
| break |
| fi |
| done |
| FCFLAGS=$ac_fc_module_flag_FCFLAGS_save |
| ]) |
| rm -rf conftest.dir |
| AC_LANG_POP([Fortran]) |
| ]) |
| if test "$ac_cv_fc_module_flag" != unknown; then |
| FC_MODINC=$ac_cv_fc_module_flag |
| $1 |
| else |
| FC_MODINC= |
| m4_default([$2], |
| [AC_MSG_ERROR([unable to find compiler flag for module search path])]) |
| fi |
| AC_SUBST([FC_MODINC]) |
| # Ensure trailing whitespace is preserved in a Makefile. |
| AC_SUBST([ac_empty], [""]) |
| AC_CONFIG_COMMANDS_PRE([case $FC_MODINC in #( |
| *\ ) FC_MODINC=$FC_MODINC'${ac_empty}' ;; |
| esac])dnl |
| ]) |
| |
| |
| # AC_FC_MODULE_OUTPUT_FLAG([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) |
| # ---------------------------------------------------------------------------- |
| # Find a flag to write Fortran 90 module information to another directory. |
| # If successful, run ACTION-IF-SUCCESS (defaults to nothing), otherwise |
| # run ACTION-IF-FAILURE (defaults to failing with an error message). |
| # The module flag is cached in the ac_cv_fc_module_output_flag variable. |
| # It may contain significant trailing whitespace. |
| # |
| # For known flags, see the documentation of AC_FC_MODULE_FLAG above. |
| AC_DEFUN([AC_FC_MODULE_OUTPUT_FLAG],[ |
| AC_CACHE_CHECK([Fortran 90 module output flag], [ac_cv_fc_module_output_flag], |
| [AC_LANG_PUSH([Fortran]) |
| mkdir conftest.dir conftest.dir/sub |
| cd conftest.dir |
| ac_cv_fc_module_output_flag=unknown |
| ac_fc_module_output_flag_FCFLAGS_save=$FCFLAGS |
| # Flag ordering is significant: put flags late which some compilers use |
| # for the search path. |
| for ac_flag in -J '-J ' -fmod= -moddir= +moddir= -qmoddir= '-mod ' \ |
| '-module ' -M '-Am -M' '-e m -J '; do |
| FCFLAGS="$ac_fc_module_output_flag_FCFLAGS_save ${ac_flag}sub" |
| AC_COMPILE_IFELSE([[ |
| module conftest_module |
| contains |
| subroutine conftest_routine |
| write(*,'(a)') 'gotcha!' |
| end subroutine |
| end module]], |
| [cd sub |
| AC_COMPILE_IFELSE([[ |
| program main |
| use conftest_module |
| call conftest_routine |
| end program]], |
| [ac_cv_fc_module_output_flag="$ac_flag"]) |
| cd .. |
| if test "$ac_cv_fc_module_output_flag" != unknown; then |
| break |
| fi]) |
| done |
| FCFLAGS=$ac_fc_module_output_flag_FCFLAGS_save |
| cd .. |
| rm -rf conftest.dir |
| AC_LANG_POP([Fortran]) |
| ]) |
| if test "$ac_cv_fc_module_output_flag" != unknown; then |
| FC_MODOUT=$ac_cv_fc_module_output_flag |
| $1 |
| else |
| FC_MODOUT= |
| m4_default([$2], |
| [AC_MSG_ERROR([unable to find compiler flag to write module information to])]) |
| fi |
| AC_SUBST([FC_MODOUT]) |
| # Ensure trailing whitespace is preserved in a Makefile. |
| AC_SUBST([ac_empty], [""]) |
| AC_CONFIG_COMMANDS_PRE([case $FC_MODOUT in #( |
| *\ ) FC_MODOUT=$FC_MODOUT'${ac_empty}' ;; |
| esac])dnl |
| ]) |